Merge branch 'develop' into hamdi/fault.detector.logging

.circleci/config.yml

@@ -1098,7 +1098,7 @@ jobs:
             ./hive \
             -sim=<<parameters.sim>> \
             -sim.loglevel=5 \
-            -client=go-ethereum,op-geth_optimism,op-proposer_<<parameters.version>>,op-batcher_<<parameters.version>>,op-node_<<parameters.version>> |& tee /tmp/hive.log || echo "failed."
+            -client=go-ethereum_v1.11.6,op-geth_optimism,op-proposer_<<parameters.version>>,op-batcher_<<parameters.version>>,op-node_<<parameters.version>> |& tee /tmp/hive.log || echo "failed."
       - run:
           command: |
             tar -cvf /tmp/workspace.tgz -C /home/circleci/project /home/circleci/project/workspace

op-node/p2p/cli/load_config.go

@@ -70,9 +70,6 @@ func NewConfig(ctx *cli.Context, blockTime uint64) (*p2p.Config, error) {
 		return nil, fmt.Errorf("failed to load p2p topic scoring options: %w", err)
 	}
 
-	conf.ConnGater = p2p.DefaultConnGater
-	conf.ConnMngr = p2p.DefaultConnManager
-
 	conf.EnableReqRespSync = ctx.GlobalBool(flags.SyncReqRespFlag.Name)
 
 	return conf, nil

op-node/p2p/config.go

@@ -106,9 +106,6 @@ type Config struct {
 	// Underlying store that hosts connection-gater and peerstore data.
 	Store ds.Batching
 
-	ConnGater func(conf *Config) (connmgr.ConnectionGater, error)
-	ConnMngr  func(conf *Config) (connmgr.ConnManager, error)
-
 	EnableReqRespSync bool
 }
 
@@ -193,12 +190,6 @@ func (conf *Config) Check() error {
 	if conf.PeersLo == 0 || conf.PeersHi == 0 || conf.PeersLo > conf.PeersHi {
 		return fmt.Errorf("peers lo/hi tides are invalid: %d, %d", conf.PeersLo, conf.PeersHi)
 	}
-	if conf.ConnMngr == nil {
-		return errors.New("need a connection manager")
-	}
-	if conf.ConnGater == nil {
-		return errors.New("need a connection gater")
-	}
 	if conf.MeshD <= 0 || conf.MeshD > maxMeshParam {
 		return fmt.Errorf("mesh D param must not be 0 or exceed %d, but got %d", maxMeshParam, conf.MeshD)
 	}

op-node/p2p/host.go

@@ -144,12 +144,12 @@ func (conf *Config) Host(log log.Logger, reporter metrics.Reporter) (host.Host,
 		return nil, fmt.Errorf("failed to set up peerstore with pub key: %w", err)
 	}
 
-	connGtr, err := conf.ConnGater(conf)
+	connGtr, err := DefaultConnGater(conf)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open connection gater: %w", err)
 	}
 
-	connMngr, err := conf.ConnMngr(conf)
+	connMngr, err := DefaultConnManager(conf)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open connection manager: %w", err)
 	}

op-node/p2p/host_test.go

@@ -12,12 +12,10 @@ import (
 	ds "github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/sync"
 	"github.com/libp2p/go-libp2p"
-	"github.com/libp2p/go-libp2p/core/connmgr"
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
-	tswarm "github.com/libp2p/go-libp2p/p2p/net/swarm/testing"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/slices"
 
@@ -54,10 +52,6 @@ func TestingConfig(t *testing.T) *Config {
 		TimeoutAccept:       time.Second * 2,
 		TimeoutDial:         time.Second * 2,
 		Store:               sync.MutexWrap(ds.NewMapDatastore()),
-		ConnGater: func(conf *Config) (connmgr.ConnectionGater, error) {
-			return tswarm.DefaultMockConnectionGater(), nil
-		},
-		ConnMngr: DefaultConnManager,
 	}
 }
 
@@ -113,8 +107,6 @@ func TestP2PFull(t *testing.T) {
 		TimeoutAccept:       time.Second * 2,
 		TimeoutDial:         time.Second * 2,
 		Store:               sync.MutexWrap(ds.NewMapDatastore()),
-		ConnGater:           DefaultConnGater,
-		ConnMngr:            DefaultConnManager,
 	}
 	// copy config A, and change the settings for B
 	confB := confA
@@ -262,8 +254,6 @@ func TestDiscovery(t *testing.T) {
 		TimeoutDial:         time.Second * 2,
 		Store:               sync.MutexWrap(ds.NewMapDatastore()),
 		DiscoveryDB:         discDBA,
-		ConnGater:           DefaultConnGater,
-		ConnMngr:            DefaultConnManager,
 	}
 	// copy config A, and change the settings for B
 	confB := confA

op-program/host/l1/fetcher.go

-package l1
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-type Source interface {
-	InfoByHash(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, error)
-	InfoAndTxsByHash(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Transactions, error)
-	FetchReceipts(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error)
-}
-
-type FetchingL1Oracle struct {
-	ctx    context.Context
-	logger log.Logger
-	source Source
-}
-
-func NewFetchingL1Oracle(ctx context.Context, logger log.Logger, source Source) *FetchingL1Oracle {
-	return &FetchingL1Oracle{
-		ctx:    ctx,
-		logger: logger,
-		source: source,
-	}
-}
-
-func (o *FetchingL1Oracle) HeaderByBlockHash(blockHash common.Hash) eth.BlockInfo {
-	o.logger.Trace("HeaderByBlockHash", "hash", blockHash)
-	info, err := o.source.InfoByHash(o.ctx, blockHash)
-	if err != nil {
-		panic(fmt.Errorf("retrieve block %s: %w", blockHash, err))
-	}
-	if info == nil {
-		panic(fmt.Errorf("unknown block: %s", blockHash))
-	}
-	return info
-}
-
-func (o *FetchingL1Oracle) TransactionsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Transactions) {
-	o.logger.Trace("TransactionsByBlockHash", "hash", blockHash)
-	info, txs, err := o.source.InfoAndTxsByHash(o.ctx, blockHash)
-	if err != nil {
-		panic(fmt.Errorf("retrieve transactions for block %s: %w", blockHash, err))
-	}
-	if info == nil || txs == nil {
-		panic(fmt.Errorf("unknown block: %s", blockHash))
-	}
-	return info, txs
-}
-
-func (o *FetchingL1Oracle) ReceiptsByBlockHash(blockHash common.Hash) (eth.BlockInfo, types.Receipts) {
-	o.logger.Trace("ReceiptsByBlockHash", "hash", blockHash)
-	info, rcpts, err := o.source.FetchReceipts(o.ctx, blockHash)
-	if err != nil {
-		panic(fmt.Errorf("retrieve receipts for block %s: %w", blockHash, err))
-	}
-	if info == nil || rcpts == nil {
-		panic(fmt.Errorf("unknown block: %s", blockHash))
-	}
-	return info, rcpts
-}

op-program/host/l1/fetcher_test.go

-package l1
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"testing"
-
-	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum-optimism/optimism/op-node/sources"
-	"github.com/ethereum-optimism/optimism/op-node/testlog"
-	"github.com/ethereum-optimism/optimism/op-node/testutils"
-	cll1 "github.com/ethereum-optimism/optimism/op-program/client/l1"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/stretchr/testify/require"
-)
-
-// Needs to implement the Oracle interface
-var _ cll1.Oracle = (*FetchingL1Oracle)(nil)
-
-// Want to be able to use an L1Client as the data source
-var _ Source = (*sources.L1Client)(nil)
-
-func TestHeaderByHash(t *testing.T) {
-	t.Run("Success", func(t *testing.T) {
-		expected := &testutils.MockBlockInfo{}
-		source := &stubSource{nextInfo: expected}
-		oracle := newFetchingOracle(t, source)
-
-		actual := oracle.HeaderByBlockHash(expected.Hash())
-		require.Equal(t, expected, actual)
-	})
-
-	t.Run("UnknownBlock", func(t *testing.T) {
-		oracle := newFetchingOracle(t, &stubSource{})
-		hash := common.HexToHash("0x4455")
-		require.PanicsWithError(t, fmt.Errorf("unknown block: %s", hash).Error(), func() {
-			oracle.HeaderByBlockHash(hash)
-		})
-	})
-
-	t.Run("Error", func(t *testing.T) {
-		err := errors.New("kaboom")
-		source := &stubSource{nextErr: err}
-		oracle := newFetchingOracle(t, source)
-
-		hash := common.HexToHash("0x8888")
-		require.PanicsWithError(t, fmt.Errorf("retrieve block %s: %w", hash, err).Error(), func() {
-			oracle.HeaderByBlockHash(hash)
-		})
-	})
-}
-
-func TestTransactionsByHash(t *testing.T) {
-	t.Run("Success", func(t *testing.T) {
-		expectedInfo := &testutils.MockBlockInfo{}
-		expectedTxs := types.Transactions{
-			&types.Transaction{},
-		}
-		source := &stubSource{nextInfo: expectedInfo, nextTxs: expectedTxs}
-		oracle := newFetchingOracle(t, source)
-
-		info, txs := oracle.TransactionsByBlockHash(expectedInfo.Hash())
-		require.Equal(t, expectedInfo, info)
-		require.Equal(t, expectedTxs, txs)
-	})
-
-	t.Run("UnknownBlock_NoInfo", func(t *testing.T) {
-		oracle := newFetchingOracle(t, &stubSource{})
-		hash := common.HexToHash("0x4455")
-		require.PanicsWithError(t, fmt.Errorf("unknown block: %s", hash).Error(), func() {
-			oracle.TransactionsByBlockHash(hash)
-		})
-	})
-
-	t.Run("UnknownBlock_NoTxs", func(t *testing.T) {
-		oracle := newFetchingOracle(t, &stubSource{nextInfo: &testutils.MockBlockInfo{}})
-		hash := common.HexToHash("0x4455")
-		require.PanicsWithError(t, fmt.Errorf("unknown block: %s", hash).Error(), func() {
-			oracle.TransactionsByBlockHash(hash)
-		})
-	})
-
-	t.Run("Error", func(t *testing.T) {
-		err := errors.New("kaboom")
-		source := &stubSource{nextErr: err}
-		oracle := newFetchingOracle(t, source)
-
-		hash := common.HexToHash("0x8888")
-		require.PanicsWithError(t, fmt.Errorf("retrieve transactions for block %s: %w", hash, err).Error(), func() {
-			oracle.TransactionsByBlockHash(hash)
-		})
-	})
-}
-
-func TestReceiptsByHash(t *testing.T) {
-	t.Run("Success", func(t *testing.T) {
-		expectedInfo := &testutils.MockBlockInfo{}
-		expectedRcpts := types.Receipts{
-			&types.Receipt{},
-		}
-		source := &stubSource{nextInfo: expectedInfo, nextRcpts: expectedRcpts}
-		oracle := newFetchingOracle(t, source)
-
-		info, rcpts := oracle.ReceiptsByBlockHash(expectedInfo.Hash())
-		require.Equal(t, expectedInfo, info)
-		require.Equal(t, expectedRcpts, rcpts)
-	})
-
-	t.Run("UnknownBlock_NoInfo", func(t *testing.T) {
-		oracle := newFetchingOracle(t, &stubSource{})
-		hash := common.HexToHash("0x4455")
-		require.PanicsWithError(t, fmt.Errorf("unknown block: %s", hash).Error(), func() {
-			oracle.ReceiptsByBlockHash(hash)
-		})
-	})
-
-	t.Run("UnknownBlock_NoTxs", func(t *testing.T) {
-		oracle := newFetchingOracle(t, &stubSource{nextInfo: &testutils.MockBlockInfo{}})
-		hash := common.HexToHash("0x4455")
-		require.PanicsWithError(t, fmt.Errorf("unknown block: %s", hash).Error(), func() {
-			oracle.ReceiptsByBlockHash(hash)
-		})
-	})
-
-	t.Run("Error", func(t *testing.T) {
-		err := errors.New("kaboom")
-		source := &stubSource{nextErr: err}
-		oracle := newFetchingOracle(t, source)
-
-		hash := common.HexToHash("0x8888")
-		require.PanicsWithError(t, fmt.Errorf("retrieve receipts for block %s: %w", hash, err).Error(), func() {
-			oracle.ReceiptsByBlockHash(hash)
-		})
-	})
-}
-
-func newFetchingOracle(t *testing.T, source Source) *FetchingL1Oracle {
-	return NewFetchingL1Oracle(context.Background(), testlog.Logger(t, log.LvlDebug), source)
-}
-
-type stubSource struct {
-	nextInfo  eth.BlockInfo
-	nextTxs   types.Transactions
-	nextRcpts types.Receipts
-	nextErr   error
-}
-
-func (s stubSource) InfoByHash(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, error) {
-	return s.nextInfo, s.nextErr
-}
-
-func (s stubSource) InfoAndTxsByHash(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Transactions, error) {
-	return s.nextInfo, s.nextTxs, s.nextErr
-}
-
-func (s stubSource) FetchReceipts(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error) {
-	return s.nextInfo, s.nextRcpts, s.nextErr
-}

op-program/host/l2/fetcher.go

-package l2
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-type BlockSource interface {
-	BlockByHash(ctx context.Context, blockHash common.Hash) (*types.Block, error)
-}
-
-type CallContext interface {
-	CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
-}
-
-type FetchingL2Oracle struct {
-	ctx         context.Context
-	logger      log.Logger
-	head        eth.BlockInfo
-	blockSource BlockSource
-	callContext CallContext
-}
-
-func NewFetchingL2Oracle(ctx context.Context, logger log.Logger, l2Url string, l2Head common.Hash) (*FetchingL2Oracle, error) {
-	rpcClient, err := rpc.Dial(l2Url)
-	if err != nil {
-		return nil, err
-	}
-	ethClient := ethclient.NewClient(rpcClient)
-	head, err := ethClient.HeaderByHash(ctx, l2Head)
-	if err != nil {
-		return nil, fmt.Errorf("retrieve l2 head %v: %w", l2Head, err)
-	}
-	return &FetchingL2Oracle{
-		ctx:         ctx,
-		logger:      logger,
-		head:        eth.HeaderBlockInfo(head),
-		blockSource: ethClient,
-		callContext: rpcClient,
-	}, nil
-}
-
-func (o *FetchingL2Oracle) NodeByHash(hash common.Hash) []byte {
-	// MPT nodes are stored as the hash of the node (with no prefix)
-	node, err := o.dbGet(hash.Bytes())
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-func (o *FetchingL2Oracle) CodeByHash(hash common.Hash) []byte {
-	// First try retrieving with the new code prefix
-	code, err := o.dbGet(append(rawdb.CodePrefix, hash.Bytes()...))
-	if err != nil {
-		// Fallback to the legacy un-prefixed version
-		code, err = o.dbGet(hash.Bytes())
-		if err != nil {
-			panic(err)
-		}
-	}
-	return code
-}
-
-func (o *FetchingL2Oracle) dbGet(key []byte) ([]byte, error) {
-	var node hexutil.Bytes
-	err := o.callContext.CallContext(o.ctx, &node, "debug_dbGet", hexutil.Encode(key))
-	if err != nil {
-		return nil, fmt.Errorf("fetch node %s: %w", hexutil.Encode(key), err)
-	}
-	return node, nil
-}
-
-func (o *FetchingL2Oracle) BlockByHash(blockHash common.Hash) *types.Block {
-	block, err := o.blockSource.BlockByHash(o.ctx, blockHash)
-	if err != nil {
-		panic(fmt.Errorf("fetch block %s: %w", blockHash.Hex(), err))
-	}
-	if block.NumberU64() > o.head.NumberU64() {
-		panic(fmt.Errorf("fetched block %v number %d above head block number %d", blockHash, block.NumberU64(), o.head.NumberU64()))
-	}
-	return block
-}

op-program/host/l2/fetcher_test.go

-package l2
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-	"math/rand"
-	"reflect"
-	"testing"
-
-	"github.com/ethereum-optimism/optimism/op-node/testutils"
-	cll2 "github.com/ethereum-optimism/optimism/op-program/client/l2"
-	"github.com/ethereum/go-ethereum/trie"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/stretchr/testify/require"
-)
-
-// Require the fetching oracle to implement StateOracle
-var _ cll2.StateOracle = (*FetchingL2Oracle)(nil)
-
-const headBlockNumber = 1000
-
-func TestNodeByHash(t *testing.T) {
-	rng := rand.New(rand.NewSource(1234))
-	hash := testutils.RandomHash(rng)
-
-	t.Run("Error", func(t *testing.T) {
-		stub := &stubCallContext{
-			nextErr: errors.New("oops"),
-		}
-		fetcher := newFetcher(nil, stub)
-
-		require.Panics(t, func() {
-			fetcher.NodeByHash(hash)
-		})
-	})
-
-	t.Run("Success", func(t *testing.T) {
-		expected := (hexutil.Bytes)([]byte{12, 34})
-		stub := &stubCallContext{
-			nextResult: expected,
-		}
-		fetcher := newFetcher(nil, stub)
-
-		node := fetcher.NodeByHash(hash)
-		require.EqualValues(t, expected, node)
-	})
-
-	t.Run("RequestArgs", func(t *testing.T) {
-		stub := &stubCallContext{
-			nextResult: (hexutil.Bytes)([]byte{12, 34}),
-		}
-		fetcher := newFetcher(nil, stub)
-
-		fetcher.NodeByHash(hash)
-		require.Len(t, stub.requests, 1, "should make single request")
-		req := stub.requests[0]
-		require.Equal(t, "debug_dbGet", req.method)
-		require.Equal(t, []interface{}{hash.Hex()}, req.args)
-	})
-}
-
-func TestCodeByHash(t *testing.T) {
-	rng := rand.New(rand.NewSource(1234))
-	hash := testutils.RandomHash(rng)
-
-	t.Run("Error", func(t *testing.T) {
-		stub := &stubCallContext{
-			nextErr: errors.New("oops"),
-		}
-		fetcher := newFetcher(nil, stub)
-
-		require.Panics(t, func() { fetcher.CodeByHash(hash) })
-	})
-
-	t.Run("Success", func(t *testing.T) {
-		expected := (hexutil.Bytes)([]byte{12, 34})
-		stub := &stubCallContext{
-			nextResult: expected,
-		}
-		fetcher := newFetcher(nil, stub)
-
-		node := fetcher.CodeByHash(hash)
-		require.EqualValues(t, expected, node)
-	})
-
-	t.Run("RequestArgs", func(t *testing.T) {
-		stub := &stubCallContext{
-			nextResult: (hexutil.Bytes)([]byte{12, 34}),
-		}
-		fetcher := newFetcher(nil, stub)
-
-		fetcher.CodeByHash(hash)
-		require.Len(t, stub.requests, 1, "should make single request")
-		req := stub.requests[0]
-		require.Equal(t, "debug_dbGet", req.method)
-		codeDbKey := append(rawdb.CodePrefix, hash.Bytes()...)
-		require.Equal(t, []interface{}{hexutil.Encode(codeDbKey)}, req.args)
-	})
-
-	t.Run("FallbackToUnprefixed", func(t *testing.T) {
-		stub := &stubCallContext{
-			nextErr: errors.New("not found"),
-		}
-		fetcher := newFetcher(nil, stub)
-
-		// Panics because the code can't be found with or without the prefix
-		require.Panics(t, func() { fetcher.CodeByHash(hash) })
-		require.Len(t, stub.requests, 2, "should request with and without prefix")
-		req := stub.requests[0]
-		require.Equal(t, "debug_dbGet", req.method)
-		codeDbKey := append(rawdb.CodePrefix, hash.Bytes()...)
-		require.Equal(t, []interface{}{hexutil.Encode(codeDbKey)}, req.args)
-
-		req = stub.requests[1]
-		require.Equal(t, "debug_dbGet", req.method)
-		codeDbKey = hash.Bytes()
-		require.Equal(t, []interface{}{hexutil.Encode(codeDbKey)}, req.args)
-	})
-}
-
-func TestBlockByHash(t *testing.T) {
-	rng := rand.New(rand.NewSource(1234))
-	hash := testutils.RandomHash(rng)
-
-	t.Run("Success", func(t *testing.T) {
-		block := blockWithNumber(rng, headBlockNumber-1)
-		stub := &stubBlockSource{nextResult: block}
-		fetcher := newFetcher(stub, nil)
-
-		res := fetcher.BlockByHash(hash)
-		require.Same(t, block, res)
-	})
-
-	t.Run("Error", func(t *testing.T) {
-		stub := &stubBlockSource{nextErr: errors.New("boom")}
-		fetcher := newFetcher(stub, nil)
-
-		require.Panics(t, func() {
-			fetcher.BlockByHash(hash)
-		})
-	})
-
-	t.Run("RequestArgs", func(t *testing.T) {
-		stub := &stubBlockSource{nextResult: blockWithNumber(rng, 1)}
-		fetcher := newFetcher(stub, nil)
-
-		fetcher.BlockByHash(hash)
-
-		require.Len(t, stub.requests, 1, "should make single request")
-		req := stub.requests[0]
-		require.Equal(t, hash, req.blockHash)
-	})
-
-	t.Run("PanicWhenBlockAboveHeadRequested", func(t *testing.T) {
-		// Block that the source can provide but is above the head block number
-		block := blockWithNumber(rng, headBlockNumber+1)
-
-		stub := &stubBlockSource{nextResult: block}
-		fetcher := newFetcher(stub, nil)
-
-		require.Panics(t, func() {
-			fetcher.BlockByHash(block.Hash())
-		})
-	})
-}
-
-func blockWithNumber(rng *rand.Rand, num int64) *types.Block {
-	header := testutils.RandomHeader(rng)
-	header.Number = big.NewInt(num)
-	return types.NewBlock(header, nil, nil, nil, trie.NewStackTrie(nil))
-}
-
-type blockRequest struct {
-	ctx       context.Context
-	blockHash common.Hash
-}
-
-type stubBlockSource struct {
-	requests   []blockRequest
-	nextErr    error
-	nextResult *types.Block
-}
-
-func (s *stubBlockSource) BlockByHash(ctx context.Context, blockHash common.Hash) (*types.Block, error) {
-	s.requests = append(s.requests, blockRequest{
-		ctx:       ctx,
-		blockHash: blockHash,
-	})
-	return s.nextResult, s.nextErr
-}
-
-type callContextRequest struct {
-	ctx    context.Context
-	method string
-	args   []interface{}
-}
-
-type stubCallContext struct {
-	nextResult any
-	nextErr    error
-	requests   []callContextRequest
-}
-
-func (c *stubCallContext) CallContext(ctx context.Context, result any, method string, args ...interface{}) error {
-	if result != nil && reflect.TypeOf(result).Kind() != reflect.Ptr {
-		return fmt.Errorf("call result parameter must be pointer or nil interface: %v", result)
-	}
-	c.requests = append(c.requests, callContextRequest{ctx: ctx, method: method, args: args})
-	if c.nextErr != nil {
-		return c.nextErr
-	}
-	res, err := json.Marshal(c.nextResult)
-	if err != nil {
-		return fmt.Errorf("json marshal: %w", err)
-	}
-	err = json.Unmarshal(res, result)
-	if err != nil {
-		return fmt.Errorf("json unmarshal: %w", err)
-	}
-	return nil
-}
-
-func newFetcher(blockSource BlockSource, callContext CallContext) *FetchingL2Oracle {
-	rng := rand.New(rand.NewSource(int64(1)))
-	head := testutils.MakeBlockInfo(func(i *testutils.MockBlockInfo) {
-		i.InfoNum = headBlockNumber
-	})(rng)
-
-	return &FetchingL2Oracle{
-		ctx:         context.Background(),
-		logger:      log.New(),
-		head:        head,
-		blockSource: blockSource,
-		callContext: callContext,
-	}
-}