// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/blocknative/dreamboat/relay (interfaces: DataAPIStore,Datastore,State,ValidatorStore,ValidatorCache,BlockValidationClient,Auctioneer,Verifier,Beacon,PayloadCache,Warehouse,Streamer)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	io "io"
	reflect "reflect"
	time "time"

	warehouse "github.com/blocknative/dreamboat/datastore/warehouse"
	types "github.com/blocknative/dreamboat/sim/client/types"
	structs "github.com/blocknative/dreamboat/structs"
	types0 "github.com/flashbots/go-boost-utils/types"
	gomock "github.com/golang/mock/gomock"
)

// MockDataAPIStore is a mock of DataAPIStore interface.
type MockDataAPIStore struct {
	ctrl     *gomock.Controller
	recorder *MockDataAPIStoreMockRecorder
}

// MockDataAPIStoreMockRecorder is the mock recorder for MockDataAPIStore.
type MockDataAPIStoreMockRecorder struct {
	mock *MockDataAPIStore
}

// NewMockDataAPIStore creates a new mock instance.
func NewMockDataAPIStore(ctrl *gomock.Controller) *MockDataAPIStore {
	mock := &MockDataAPIStore{ctrl: ctrl}
	mock.recorder = &MockDataAPIStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDataAPIStore) EXPECT() *MockDataAPIStoreMockRecorder {
	return m.recorder
}

// GetBuilderBlockSubmissions mocks base method.
func (m *MockDataAPIStore) GetBuilderBlockSubmissions(arg0 context.Context, arg1 io.Writer, arg2 uint64, arg3 structs.SubmissionTraceQuery) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuilderBlockSubmissions", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetBuilderBlockSubmissions indicates an expected call of GetBuilderBlockSubmissions.
func (mr *MockDataAPIStoreMockRecorder) GetBuilderBlockSubmissions(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuilderBlockSubmissions", reflect.TypeOf((*MockDataAPIStore)(nil).GetBuilderBlockSubmissions), arg0, arg1, arg2, arg3)
}

// GetDeliveredPayloads mocks base method.
func (m *MockDataAPIStore) GetDeliveredPayloads(arg0 context.Context, arg1 io.Writer, arg2 uint64, arg3 structs.PayloadTraceQuery) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeliveredPayloads", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetDeliveredPayloads indicates an expected call of GetDeliveredPayloads.
func (mr *MockDataAPIStoreMockRecorder) GetDeliveredPayloads(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeliveredPayloads", reflect.TypeOf((*MockDataAPIStore)(nil).GetDeliveredPayloads), arg0, arg1, arg2, arg3)
}

// PutBuilderBlockSubmission mocks base method.
func (m *MockDataAPIStore) PutBuilderBlockSubmission(arg0 context.Context, arg1 structs.BidTraceWithTimestamp, arg2 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutBuilderBlockSubmission", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutBuilderBlockSubmission indicates an expected call of PutBuilderBlockSubmission.
func (mr *MockDataAPIStoreMockRecorder) PutBuilderBlockSubmission(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBuilderBlockSubmission", reflect.TypeOf((*MockDataAPIStore)(nil).PutBuilderBlockSubmission), arg0, arg1, arg2)
}

// PutDelivered mocks base method.
func (m *MockDataAPIStore) PutDelivered(arg0 context.Context, arg1 structs.Slot, arg2 structs.DeliveredTrace) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutDelivered", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutDelivered indicates an expected call of PutDelivered.
func (mr *MockDataAPIStoreMockRecorder) PutDelivered(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutDelivered", reflect.TypeOf((*MockDataAPIStore)(nil).PutDelivered), arg0, arg1, arg2)
}

// MockDatastore is a mock of Datastore interface.
type MockDatastore struct {
	ctrl     *gomock.Controller
	recorder *MockDatastoreMockRecorder
}

// MockDatastoreMockRecorder is the mock recorder for MockDatastore.
type MockDatastoreMockRecorder struct {
	mock *MockDatastore
}

// NewMockDatastore creates a new mock instance.
func NewMockDatastore(ctrl *gomock.Controller) *MockDatastore {
	mock := &MockDatastore{ctrl: ctrl}
	mock.recorder = &MockDatastoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDatastore) EXPECT() *MockDatastoreMockRecorder {
	return m.recorder
}

// GetPayload mocks base method.
func (m *MockDatastore) GetPayload(arg0 context.Context, arg1 structs.ForkVersion, arg2 structs.PayloadKey) (structs.BlockAndTraceExtended, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPayload", arg0, arg1, arg2)
	ret0, _ := ret[0].(structs.BlockAndTraceExtended)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPayload indicates an expected call of GetPayload.
func (mr *MockDatastoreMockRecorder) GetPayload(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPayload", reflect.TypeOf((*MockDatastore)(nil).GetPayload), arg0, arg1, arg2)
}

// PutPayload mocks base method.
func (m *MockDatastore) PutPayload(arg0 context.Context, arg1 structs.PayloadKey, arg2 structs.BlockAndTraceExtended, arg3 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPayload", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutPayload indicates an expected call of PutPayload.
func (mr *MockDatastoreMockRecorder) PutPayload(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPayload", reflect.TypeOf((*MockDatastore)(nil).PutPayload), arg0, arg1, arg2, arg3)
}

// MockState is a mock of State interface.
type MockState struct {
	ctrl     *gomock.Controller
	recorder *MockStateMockRecorder
}

// MockStateMockRecorder is the mock recorder for MockState.
type MockStateMockRecorder struct {
	mock *MockState
}

// NewMockState creates a new mock instance.
func NewMockState(ctrl *gomock.Controller) *MockState {
	mock := &MockState{ctrl: ctrl}
	mock.recorder = &MockStateMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockState) EXPECT() *MockStateMockRecorder {
	return m.recorder
}

// ForkVersion mocks base method.
func (m *MockState) ForkVersion(arg0 structs.Slot) structs.ForkVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForkVersion", arg0)
	ret0, _ := ret[0].(structs.ForkVersion)
	return ret0
}

// ForkVersion indicates an expected call of ForkVersion.
func (mr *MockStateMockRecorder) ForkVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkVersion", reflect.TypeOf((*MockState)(nil).ForkVersion), arg0)
}

// Genesis mocks base method.
func (m *MockState) Genesis() structs.GenesisInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Genesis")
	ret0, _ := ret[0].(structs.GenesisInfo)
	return ret0
}

// Genesis indicates an expected call of Genesis.
func (mr *MockStateMockRecorder) Genesis() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Genesis", reflect.TypeOf((*MockState)(nil).Genesis))
}

// HeadSlot mocks base method.
func (m *MockState) HeadSlot() structs.Slot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadSlot")
	ret0, _ := ret[0].(structs.Slot)
	return ret0
}

// HeadSlot indicates an expected call of HeadSlot.
func (mr *MockStateMockRecorder) HeadSlot() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadSlot", reflect.TypeOf((*MockState)(nil).HeadSlot))
}

// KnownValidators mocks base method.
func (m *MockState) KnownValidators() structs.ValidatorsState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KnownValidators")
	ret0, _ := ret[0].(structs.ValidatorsState)
	return ret0
}

// KnownValidators indicates an expected call of KnownValidators.
func (mr *MockStateMockRecorder) KnownValidators() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnownValidators", reflect.TypeOf((*MockState)(nil).KnownValidators))
}

// Randao mocks base method.
func (m *MockState) Randao(arg0 uint64, arg1 types0.Hash) structs.RandaoState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Randao", arg0, arg1)
	ret0, _ := ret[0].(structs.RandaoState)
	return ret0
}

// Randao indicates an expected call of Randao.
func (mr *MockStateMockRecorder) Randao(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Randao", reflect.TypeOf((*MockState)(nil).Randao), arg0, arg1)
}

// Withdrawals mocks base method.
func (m *MockState) Withdrawals(arg0 uint64, arg1 types0.Hash) structs.WithdrawalsState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Withdrawals", arg0, arg1)
	ret0, _ := ret[0].(structs.WithdrawalsState)
	return ret0
}

// Withdrawals indicates an expected call of Withdrawals.
func (mr *MockStateMockRecorder) Withdrawals(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Withdrawals", reflect.TypeOf((*MockState)(nil).Withdrawals), arg0, arg1)
}

// MockValidatorStore is a mock of ValidatorStore interface.
type MockValidatorStore struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorStoreMockRecorder
}

// MockValidatorStoreMockRecorder is the mock recorder for MockValidatorStore.
type MockValidatorStoreMockRecorder struct {
	mock *MockValidatorStore
}

// NewMockValidatorStore creates a new mock instance.
func NewMockValidatorStore(ctrl *gomock.Controller) *MockValidatorStore {
	mock := &MockValidatorStore{ctrl: ctrl}
	mock.recorder = &MockValidatorStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockValidatorStore) EXPECT() *MockValidatorStoreMockRecorder {
	return m.recorder
}

// GetRegistration mocks base method.
func (m *MockValidatorStore) GetRegistration(arg0 context.Context, arg1 types0.PublicKey) (types0.SignedValidatorRegistration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegistration", arg0, arg1)
	ret0, _ := ret[0].(types0.SignedValidatorRegistration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRegistration indicates an expected call of GetRegistration.
func (mr *MockValidatorStoreMockRecorder) GetRegistration(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegistration", reflect.TypeOf((*MockValidatorStore)(nil).GetRegistration), arg0, arg1)
}

// MockValidatorCache is a mock of ValidatorCache interface.
type MockValidatorCache struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorCacheMockRecorder
}

// MockValidatorCacheMockRecorder is the mock recorder for MockValidatorCache.
type MockValidatorCacheMockRecorder struct {
	mock *MockValidatorCache
}

// NewMockValidatorCache creates a new mock instance.
func NewMockValidatorCache(ctrl *gomock.Controller) *MockValidatorCache {
	mock := &MockValidatorCache{ctrl: ctrl}
	mock.recorder = &MockValidatorCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockValidatorCache) EXPECT() *MockValidatorCacheMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockValidatorCache) Add(arg0 types0.PublicKey, arg1 structs.ValidatorCacheEntry) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockValidatorCacheMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockValidatorCache)(nil).Add), arg0, arg1)
}

// Get mocks base method.
func (m *MockValidatorCache) Get(arg0 types0.PublicKey) (structs.ValidatorCacheEntry, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(structs.ValidatorCacheEntry)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockValidatorCacheMockRecorder) Get(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockValidatorCache)(nil).Get), arg0)
}

// Remove mocks base method.
func (m *MockValidatorCache) Remove(arg0 types0.PublicKey) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Remove", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Remove indicates an expected call of Remove.
func (mr *MockValidatorCacheMockRecorder) Remove(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockValidatorCache)(nil).Remove), arg0)
}

// MockBlockValidationClient is a mock of BlockValidationClient interface.
type MockBlockValidationClient struct {
	ctrl     *gomock.Controller
	recorder *MockBlockValidationClientMockRecorder
}

// MockBlockValidationClientMockRecorder is the mock recorder for MockBlockValidationClient.
type MockBlockValidationClientMockRecorder struct {
	mock *MockBlockValidationClient
}

// NewMockBlockValidationClient creates a new mock instance.
func NewMockBlockValidationClient(ctrl *gomock.Controller) *MockBlockValidationClient {
	mock := &MockBlockValidationClient{ctrl: ctrl}
	mock.recorder = &MockBlockValidationClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBlockValidationClient) EXPECT() *MockBlockValidationClientMockRecorder {
	return m.recorder
}

// IsSet mocks base method.
func (m *MockBlockValidationClient) IsSet() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSet")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsSet indicates an expected call of IsSet.
func (mr *MockBlockValidationClientMockRecorder) IsSet() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSet", reflect.TypeOf((*MockBlockValidationClient)(nil).IsSet))
}

// ValidateBlock mocks base method.
func (m *MockBlockValidationClient) ValidateBlock(arg0 context.Context, arg1 *types.BuilderBlockValidationRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateBlock", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateBlock indicates an expected call of ValidateBlock.
func (mr *MockBlockValidationClientMockRecorder) ValidateBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateBlock", reflect.TypeOf((*MockBlockValidationClient)(nil).ValidateBlock), arg0, arg1)
}

// ValidateBlockV2 mocks base method.
func (m *MockBlockValidationClient) ValidateBlockV2(arg0 context.Context, arg1 *types.BuilderBlockValidationRequestV2) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateBlockV2", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateBlockV2 indicates an expected call of ValidateBlockV2.
func (mr *MockBlockValidationClientMockRecorder) ValidateBlockV2(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateBlockV2", reflect.TypeOf((*MockBlockValidationClient)(nil).ValidateBlockV2), arg0, arg1)
}

// MockAuctioneer is a mock of Auctioneer interface.
type MockAuctioneer struct {
	ctrl     *gomock.Controller
	recorder *MockAuctioneerMockRecorder
}

// MockAuctioneerMockRecorder is the mock recorder for MockAuctioneer.
type MockAuctioneerMockRecorder struct {
	mock *MockAuctioneer
}

// NewMockAuctioneer creates a new mock instance.
func NewMockAuctioneer(ctrl *gomock.Controller) *MockAuctioneer {
	mock := &MockAuctioneer{ctrl: ctrl}
	mock.recorder = &MockAuctioneerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuctioneer) EXPECT() *MockAuctioneerMockRecorder {
	return m.recorder
}

// AddBlock mocks base method.
func (m *MockAuctioneer) AddBlock(arg0 structs.BuilderBidExtended) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBlock", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// AddBlock indicates an expected call of AddBlock.
func (mr *MockAuctioneerMockRecorder) AddBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockAuctioneer)(nil).AddBlock), arg0)
}

// MaxProfitBlock mocks base method.
func (m *MockAuctioneer) MaxProfitBlock(arg0 structs.Slot, arg1 types0.Hash) (structs.BuilderBidExtended, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaxProfitBlock", arg0, arg1)
	ret0, _ := ret[0].(structs.BuilderBidExtended)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// MaxProfitBlock indicates an expected call of MaxProfitBlock.
func (mr *MockAuctioneerMockRecorder) MaxProfitBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxProfitBlock", reflect.TypeOf((*MockAuctioneer)(nil).MaxProfitBlock), arg0, arg1)
}

// MockVerifier is a mock of Verifier interface.
type MockVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockVerifierMockRecorder
}

// MockVerifierMockRecorder is the mock recorder for MockVerifier.
type MockVerifierMockRecorder struct {
	mock *MockVerifier
}

// NewMockVerifier creates a new mock instance.
func NewMockVerifier(ctrl *gomock.Controller) *MockVerifier {
	mock := &MockVerifier{ctrl: ctrl}
	mock.recorder = &MockVerifierMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVerifier) EXPECT() *MockVerifierMockRecorder {
	return m.recorder
}

// Enqueue mocks base method.
func (m *MockVerifier) Enqueue(arg0 context.Context, arg1 [96]byte, arg2 [48]byte, arg3 [32]byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enqueue", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Enqueue indicates an expected call of Enqueue.
func (mr *MockVerifierMockRecorder) Enqueue(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enqueue", reflect.TypeOf((*MockVerifier)(nil).Enqueue), arg0, arg1, arg2, arg3)
}

// MockBeacon is a mock of Beacon interface.
type MockBeacon struct {
	ctrl     *gomock.Controller
	recorder *MockBeaconMockRecorder
}

// MockBeaconMockRecorder is the mock recorder for MockBeacon.
type MockBeaconMockRecorder struct {
	mock *MockBeacon
}

// NewMockBeacon creates a new mock instance.
func NewMockBeacon(ctrl *gomock.Controller) *MockBeacon {
	mock := &MockBeacon{ctrl: ctrl}
	mock.recorder = &MockBeaconMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBeacon) EXPECT() *MockBeaconMockRecorder {
	return m.recorder
}

// PublishBlock mocks base method.
func (m *MockBeacon) PublishBlock(arg0 context.Context, arg1 structs.SignedBeaconBlock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishBlock", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PublishBlock indicates an expected call of PublishBlock.
func (mr *MockBeaconMockRecorder) PublishBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishBlock", reflect.TypeOf((*MockBeacon)(nil).PublishBlock), arg0, arg1)
}

// MockPayloadCache is a mock of PayloadCache interface.
type MockPayloadCache struct {
	ctrl     *gomock.Controller
	recorder *MockPayloadCacheMockRecorder
}

// MockPayloadCacheMockRecorder is the mock recorder for MockPayloadCache.
type MockPayloadCacheMockRecorder struct {
	mock *MockPayloadCache
}

// NewMockPayloadCache creates a new mock instance.
func NewMockPayloadCache(ctrl *gomock.Controller) *MockPayloadCache {
	mock := &MockPayloadCache{ctrl: ctrl}
	mock.recorder = &MockPayloadCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPayloadCache) EXPECT() *MockPayloadCacheMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockPayloadCache) Add(arg0 structs.PayloadKey, arg1 structs.BlockAndTraceExtended) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockPayloadCacheMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockPayloadCache)(nil).Add), arg0, arg1)
}

// ContainsOrAdd mocks base method.
func (m *MockPayloadCache) ContainsOrAdd(arg0 structs.PayloadKey, arg1 structs.BlockAndTraceExtended) (bool, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainsOrAdd", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// ContainsOrAdd indicates an expected call of ContainsOrAdd.
func (mr *MockPayloadCacheMockRecorder) ContainsOrAdd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsOrAdd", reflect.TypeOf((*MockPayloadCache)(nil).ContainsOrAdd), arg0, arg1)
}

// Get mocks base method.
func (m *MockPayloadCache) Get(arg0 structs.PayloadKey) (structs.BlockAndTraceExtended, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(structs.BlockAndTraceExtended)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockPayloadCacheMockRecorder) Get(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPayloadCache)(nil).Get), arg0)
}

// MockWarehouse is a mock of Warehouse interface.
type MockWarehouse struct {
	ctrl     *gomock.Controller
	recorder *MockWarehouseMockRecorder
}

// MockWarehouseMockRecorder is the mock recorder for MockWarehouse.
type MockWarehouseMockRecorder struct {
	mock *MockWarehouse
}

// NewMockWarehouse creates a new mock instance.
func NewMockWarehouse(ctrl *gomock.Controller) *MockWarehouse {
	mock := &MockWarehouse{ctrl: ctrl}
	mock.recorder = &MockWarehouseMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWarehouse) EXPECT() *MockWarehouseMockRecorder {
	return m.recorder
}

// StoreAsync mocks base method.
func (m *MockWarehouse) StoreAsync(arg0 context.Context, arg1 warehouse.StoreRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StoreAsync", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// StoreAsync indicates an expected call of StoreAsync.
func (mr *MockWarehouseMockRecorder) StoreAsync(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreAsync", reflect.TypeOf((*MockWarehouse)(nil).StoreAsync), arg0, arg1)
}

// MockStreamer is a mock of Streamer interface.
type MockStreamer struct {
	ctrl     *gomock.Controller
	recorder *MockStreamerMockRecorder
}

// MockStreamerMockRecorder is the mock recorder for MockStreamer.
type MockStreamerMockRecorder struct {
	mock *MockStreamer
}

// NewMockStreamer creates a new mock instance.
func NewMockStreamer(ctrl *gomock.Controller) *MockStreamer {
	mock := &MockStreamer{ctrl: ctrl}
	mock.recorder = &MockStreamerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStreamer) EXPECT() *MockStreamerMockRecorder {
	return m.recorder
}

// BlockCache mocks base method.
func (m *MockStreamer) BlockCache() <-chan structs.BlockAndTraceExtended {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockCache")
	ret0, _ := ret[0].(<-chan structs.BlockAndTraceExtended)
	return ret0
}

// BlockCache indicates an expected call of BlockCache.
func (mr *MockStreamerMockRecorder) BlockCache() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockCache", reflect.TypeOf((*MockStreamer)(nil).BlockCache))
}

// BuilderBid mocks base method.
func (m *MockStreamer) BuilderBid() <-chan structs.BuilderBidExtended {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuilderBid")
	ret0, _ := ret[0].(<-chan structs.BuilderBidExtended)
	return ret0
}

// BuilderBid indicates an expected call of BuilderBid.
func (mr *MockStreamerMockRecorder) BuilderBid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuilderBid", reflect.TypeOf((*MockStreamer)(nil).BuilderBid))
}

// PublishBlockCache mocks base method.
func (m *MockStreamer) PublishBlockCache(arg0 context.Context, arg1 structs.BlockAndTraceExtended) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishBlockCache", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PublishBlockCache indicates an expected call of PublishBlockCache.
func (mr *MockStreamerMockRecorder) PublishBlockCache(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishBlockCache", reflect.TypeOf((*MockStreamer)(nil).PublishBlockCache), arg0, arg1)
}

// PublishBuilderBid mocks base method.
func (m *MockStreamer) PublishBuilderBid(arg0 context.Context, arg1 structs.BuilderBidExtended) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishBuilderBid", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PublishBuilderBid indicates an expected call of PublishBuilderBid.
func (mr *MockStreamerMockRecorder) PublishBuilderBid(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishBuilderBid", reflect.TypeOf((*MockStreamer)(nil).PublishBuilderBid), arg0, arg1)
}
