check in mocks

test_helpers/mocks/gen_backend.go

@@ -0,0 +1,567 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/openrelayxyz/plugeth-utils/core (interfaces: Backend,Downloader)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	context "context"
+	big "math/big"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+	core "github.com/openrelayxyz/plugeth-utils/core"
+)
+
+// MockBackend is a mock of Backend interface.
+type MockBackend struct {
+	ctrl     *gomock.Controller
+	recorder *MockBackendMockRecorder
+}
+
+// MockBackendMockRecorder is the mock recorder for MockBackend.
+type MockBackendMockRecorder struct {
+	mock *MockBackend
+}
+
+// NewMockBackend creates a new mock instance.
+func NewMockBackend(ctrl *gomock.Controller) *MockBackend {
+	mock := &MockBackend{ctrl: ctrl}
+	mock.recorder = &MockBackendMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBackend) EXPECT() *MockBackendMockRecorder {
+	return m.recorder
+}
+
+// BlockByHash mocks base method.
+func (m *MockBackend) BlockByHash(arg0 context.Context, arg1 core.Hash) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BlockByHash", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BlockByHash indicates an expected call of BlockByHash.
+func (mr *MockBackendMockRecorder) BlockByHash(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockBackend)(nil).BlockByHash), arg0, arg1)
+}
+
+// BlockByNumber mocks base method.
+func (m *MockBackend) BlockByNumber(arg0 context.Context, arg1 int64) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BlockByNumber", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BlockByNumber indicates an expected call of BlockByNumber.
+func (mr *MockBackendMockRecorder) BlockByNumber(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockBackend)(nil).BlockByNumber), arg0, arg1)
+}
+
+// BloomStatus mocks base method.
+func (m *MockBackend) BloomStatus() (uint64, uint64) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BloomStatus")
+	ret0, _ := ret[0].(uint64)
+	ret1, _ := ret[1].(uint64)
+	return ret0, ret1
+}
+
+// BloomStatus indicates an expected call of BloomStatus.
+func (mr *MockBackendMockRecorder) BloomStatus() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BloomStatus", reflect.TypeOf((*MockBackend)(nil).BloomStatus))
+}
+
+// CurrentBlock mocks base method.
+func (m *MockBackend) CurrentBlock() []byte {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CurrentBlock")
+	ret0, _ := ret[0].([]byte)
+	return ret0
+}
+
+// CurrentBlock indicates an expected call of CurrentBlock.
+func (mr *MockBackendMockRecorder) CurrentBlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentBlock", reflect.TypeOf((*MockBackend)(nil).CurrentBlock))
+}
+
+// CurrentHeader mocks base method.
+func (m *MockBackend) CurrentHeader() []byte {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CurrentHeader")
+	ret0, _ := ret[0].([]byte)
+	return ret0
+}
+
+// CurrentHeader indicates an expected call of CurrentHeader.
+func (mr *MockBackendMockRecorder) CurrentHeader() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentHeader", reflect.TypeOf((*MockBackend)(nil).CurrentHeader))
+}
+
+// Downloader mocks base method.
+func (m *MockBackend) Downloader() core.Downloader {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Downloader")
+	ret0, _ := ret[0].(core.Downloader)
+	return ret0
+}
+
+// Downloader indicates an expected call of Downloader.
+func (mr *MockBackendMockRecorder) Downloader() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Downloader", reflect.TypeOf((*MockBackend)(nil).Downloader))
+}
+
+// ExtRPCEnabled mocks base method.
+func (m *MockBackend) ExtRPCEnabled() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExtRPCEnabled")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// ExtRPCEnabled indicates an expected call of ExtRPCEnabled.
+func (mr *MockBackendMockRecorder) ExtRPCEnabled() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtRPCEnabled", reflect.TypeOf((*MockBackend)(nil).ExtRPCEnabled))
+}
+
+// GetAccountTrie mocks base method.
+func (m *MockBackend) GetAccountTrie(arg0 core.Hash, arg1 core.Address) (core.Trie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAccountTrie", arg0, arg1)
+	ret0, _ := ret[0].(core.Trie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAccountTrie indicates an expected call of GetAccountTrie.
+func (mr *MockBackendMockRecorder) GetAccountTrie(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountTrie", reflect.TypeOf((*MockBackend)(nil).GetAccountTrie), arg0, arg1)
+}
+
+// GetContractCode mocks base method.
+func (m *MockBackend) GetContractCode(arg0 core.Hash) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetContractCode", arg0)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetContractCode indicates an expected call of GetContractCode.
+func (mr *MockBackendMockRecorder) GetContractCode(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractCode", reflect.TypeOf((*MockBackend)(nil).GetContractCode), arg0)
+}
+
+// GetLogs mocks base method.
+func (m *MockBackend) GetLogs(arg0 context.Context, arg1 core.Hash) ([][]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLogs", arg0, arg1)
+	ret0, _ := ret[0].([][]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLogs indicates an expected call of GetLogs.
+func (mr *MockBackendMockRecorder) GetLogs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockBackend)(nil).GetLogs), arg0, arg1)
+}
+
+// GetPoolNonce mocks base method.
+func (m *MockBackend) GetPoolNonce(arg0 context.Context, arg1 core.Address) (uint64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPoolNonce", arg0, arg1)
+	ret0, _ := ret[0].(uint64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPoolNonce indicates an expected call of GetPoolNonce.
+func (mr *MockBackendMockRecorder) GetPoolNonce(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolNonce", reflect.TypeOf((*MockBackend)(nil).GetPoolNonce), arg0, arg1)
+}
+
+// GetPoolTransaction mocks base method.
+func (m *MockBackend) GetPoolTransaction(arg0 core.Hash) []byte {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPoolTransaction", arg0)
+	ret0, _ := ret[0].([]byte)
+	return ret0
+}
+
+// GetPoolTransaction indicates an expected call of GetPoolTransaction.
+func (mr *MockBackendMockRecorder) GetPoolTransaction(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolTransaction", reflect.TypeOf((*MockBackend)(nil).GetPoolTransaction), arg0)
+}
+
+// GetPoolTransactions mocks base method.
+func (m *MockBackend) GetPoolTransactions() ([][]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPoolTransactions")
+	ret0, _ := ret[0].([][]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPoolTransactions indicates an expected call of GetPoolTransactions.
+func (mr *MockBackendMockRecorder) GetPoolTransactions() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolTransactions", reflect.TypeOf((*MockBackend)(nil).GetPoolTransactions))
+}
+
+// GetReceipts mocks base method.
+func (m *MockBackend) GetReceipts(arg0 context.Context, arg1 core.Hash) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetReceipts", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetReceipts indicates an expected call of GetReceipts.
+func (mr *MockBackendMockRecorder) GetReceipts(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipts", reflect.TypeOf((*MockBackend)(nil).GetReceipts), arg0, arg1)
+}
+
+// GetTd mocks base method.
+func (m *MockBackend) GetTd(arg0 context.Context, arg1 core.Hash) *big.Int {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTd", arg0, arg1)
+	ret0, _ := ret[0].(*big.Int)
+	return ret0
+}
+
+// GetTd indicates an expected call of GetTd.
+func (mr *MockBackendMockRecorder) GetTd(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTd", reflect.TypeOf((*MockBackend)(nil).GetTd), arg0, arg1)
+}
+
+// GetTransaction mocks base method.
+func (m *MockBackend) GetTransaction(arg0 context.Context, arg1 core.Hash) ([]byte, core.Hash, uint64, uint64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTransaction", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(core.Hash)
+	ret2, _ := ret[2].(uint64)
+	ret3, _ := ret[3].(uint64)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// GetTransaction indicates an expected call of GetTransaction.
+func (mr *MockBackendMockRecorder) GetTransaction(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransaction", reflect.TypeOf((*MockBackend)(nil).GetTransaction), arg0, arg1)
+}
+
+// GetTrie mocks base method.
+func (m *MockBackend) GetTrie(arg0 core.Hash) (core.Trie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTrie", arg0)
+	ret0, _ := ret[0].(core.Trie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTrie indicates an expected call of GetTrie.
+func (mr *MockBackendMockRecorder) GetTrie(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrie", reflect.TypeOf((*MockBackend)(nil).GetTrie), arg0)
+}
+
+// HeaderByHash mocks base method.
+func (m *MockBackend) HeaderByHash(arg0 context.Context, arg1 core.Hash) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HeaderByHash", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HeaderByHash indicates an expected call of HeaderByHash.
+func (mr *MockBackendMockRecorder) HeaderByHash(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBackend)(nil).HeaderByHash), arg0, arg1)
+}
+
+// HeaderByNumber mocks base method.
+func (m *MockBackend) HeaderByNumber(arg0 context.Context, arg1 int64) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HeaderByNumber", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HeaderByNumber indicates an expected call of HeaderByNumber.
+func (mr *MockBackendMockRecorder) HeaderByNumber(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), arg0, arg1)
+}
+
+// RPCGasCap mocks base method.
+func (m *MockBackend) RPCGasCap() uint64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RPCGasCap")
+	ret0, _ := ret[0].(uint64)
+	return ret0
+}
+
+// RPCGasCap indicates an expected call of RPCGasCap.
+func (mr *MockBackendMockRecorder) RPCGasCap() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPCGasCap", reflect.TypeOf((*MockBackend)(nil).RPCGasCap))
+}
+
+// RPCTxFeeCap mocks base method.
+func (m *MockBackend) RPCTxFeeCap() float64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RPCTxFeeCap")
+	ret0, _ := ret[0].(float64)
+	return ret0
+}
+
+// RPCTxFeeCap indicates an expected call of RPCTxFeeCap.
+func (mr *MockBackendMockRecorder) RPCTxFeeCap() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPCTxFeeCap", reflect.TypeOf((*MockBackend)(nil).RPCTxFeeCap))
+}
+
+// SendTx mocks base method.
+func (m *MockBackend) SendTx(arg0 context.Context, arg1 []byte) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SendTx", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SendTx indicates an expected call of SendTx.
+func (mr *MockBackendMockRecorder) SendTx(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTx", reflect.TypeOf((*MockBackend)(nil).SendTx), arg0, arg1)
+}
+
+// SetHead mocks base method.
+func (m *MockBackend) SetHead(arg0 uint64) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetHead", arg0)
+}
+
+// SetHead indicates an expected call of SetHead.
+func (mr *MockBackendMockRecorder) SetHead(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockBackend)(nil).SetHead), arg0)
+}
+
+// Stats mocks base method.
+func (m *MockBackend) Stats() (int, int) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Stats")
+	ret0, _ := ret[0].(int)
+	ret1, _ := ret[1].(int)
+	return ret0, ret1
+}
+
+// Stats indicates an expected call of Stats.
+func (mr *MockBackendMockRecorder) Stats() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockBackend)(nil).Stats))
+}
+
+// SubscribeChainEvent mocks base method.
+func (m *MockBackend) SubscribeChainEvent(arg0 chan<- core.ChainEvent) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeChainEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribeChainEvent indicates an expected call of SubscribeChainEvent.
+func (mr *MockBackendMockRecorder) SubscribeChainEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainEvent), arg0)
+}
+
+// SubscribeChainHeadEvent mocks base method.
+func (m *MockBackend) SubscribeChainHeadEvent(arg0 chan<- core.ChainHeadEvent) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeChainHeadEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribeChainHeadEvent indicates an expected call of SubscribeChainHeadEvent.
+func (mr *MockBackendMockRecorder) SubscribeChainHeadEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainHeadEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainHeadEvent), arg0)
+}
+
+// SubscribeChainSideEvent mocks base method.
+func (m *MockBackend) SubscribeChainSideEvent(arg0 chan<- core.ChainSideEvent) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeChainSideEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribeChainSideEvent indicates an expected call of SubscribeChainSideEvent.
+func (mr *MockBackendMockRecorder) SubscribeChainSideEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainSideEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainSideEvent), arg0)
+}
+
+// SubscribeLogsEvent mocks base method.
+func (m *MockBackend) SubscribeLogsEvent(arg0 chan<- [][]byte) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeLogsEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribeLogsEvent indicates an expected call of SubscribeLogsEvent.
+func (mr *MockBackendMockRecorder) SubscribeLogsEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeLogsEvent), arg0)
+}
+
+// SubscribeNewTxsEvent mocks base method.
+func (m *MockBackend) SubscribeNewTxsEvent(arg0 chan<- core.NewTxsEvent) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeNewTxsEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribeNewTxsEvent indicates an expected call of SubscribeNewTxsEvent.
+func (mr *MockBackendMockRecorder) SubscribeNewTxsEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeNewTxsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeNewTxsEvent), arg0)
+}
+
+// SubscribePendingLogsEvent mocks base method.
+func (m *MockBackend) SubscribePendingLogsEvent(arg0 chan<- [][]byte) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribePendingLogsEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribePendingLogsEvent indicates an expected call of SubscribePendingLogsEvent.
+func (mr *MockBackendMockRecorder) SubscribePendingLogsEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribePendingLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribePendingLogsEvent), arg0)
+}
+
+// SubscribeRemovedLogsEvent mocks base method.
+func (m *MockBackend) SubscribeRemovedLogsEvent(arg0 chan<- []byte) core.Subscription {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeRemovedLogsEvent", arg0)
+	ret0, _ := ret[0].(core.Subscription)
+	return ret0
+}
+
+// SubscribeRemovedLogsEvent indicates an expected call of SubscribeRemovedLogsEvent.
+func (mr *MockBackendMockRecorder) SubscribeRemovedLogsEvent(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeRemovedLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeRemovedLogsEvent), arg0)
+}
+
+// SuggestGasTipCap mocks base method.
+func (m *MockBackend) SuggestGasTipCap(arg0 context.Context) (*big.Int, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SuggestGasTipCap", arg0)
+	ret0, _ := ret[0].(*big.Int)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SuggestGasTipCap indicates an expected call of SuggestGasTipCap.
+func (mr *MockBackendMockRecorder) SuggestGasTipCap(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasTipCap", reflect.TypeOf((*MockBackend)(nil).SuggestGasTipCap), arg0)
+}
+
+// TxPoolContent mocks base method.
+func (m *MockBackend) TxPoolContent() (map[core.Address][][]byte, map[core.Address][][]byte) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TxPoolContent")
+	ret0, _ := ret[0].(map[core.Address][][]byte)
+	ret1, _ := ret[1].(map[core.Address][][]byte)
+	return ret0, ret1
+}
+
+// TxPoolContent indicates an expected call of TxPoolContent.
+func (mr *MockBackendMockRecorder) TxPoolContent() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPoolContent", reflect.TypeOf((*MockBackend)(nil).TxPoolContent))
+}
+
+// UnprotectedAllowed mocks base method.
+func (m *MockBackend) UnprotectedAllowed() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnprotectedAllowed")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// UnprotectedAllowed indicates an expected call of UnprotectedAllowed.
+func (mr *MockBackendMockRecorder) UnprotectedAllowed() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnprotectedAllowed", reflect.TypeOf((*MockBackend)(nil).UnprotectedAllowed))
+}
+
+// MockDownloader is a mock of Downloader interface.
+type MockDownloader struct {
+	ctrl     *gomock.Controller
+	recorder *MockDownloaderMockRecorder
+}
+
+// MockDownloaderMockRecorder is the mock recorder for MockDownloader.
+type MockDownloaderMockRecorder struct {
+	mock *MockDownloader
+}
+
+// NewMockDownloader creates a new mock instance.
+func NewMockDownloader(ctrl *gomock.Controller) *MockDownloader {
+	mock := &MockDownloader{ctrl: ctrl}
+	mock.recorder = &MockDownloaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDownloader) EXPECT() *MockDownloaderMockRecorder {
+	return m.recorder
+}
+
+// Progress mocks base method.
+func (m *MockDownloader) Progress() core.Progress {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Progress")
+	ret0, _ := ret[0].(core.Progress)
+	return ret0
+}
+
+// Progress indicates an expected call of Progress.
+func (mr *MockDownloaderMockRecorder) Progress() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Progress", reflect.TypeOf((*MockDownloader)(nil).Progress))
+}