// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/erigontech/erigon/txnprovider/txpool (interfaces: Pool)
//
// Generated by this command:
//
//	mockgen -typed=true -destination=./pool_mock.go -package=txpool . Pool
//

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

import (
	context "context"
	reflect "reflect"

	common "github.com/erigontech/erigon/common"
	kv "github.com/erigontech/erigon/db/kv"
	remoteproto "github.com/erigontech/erigon/node/gointerfaces/remoteproto"
	sentryproto "github.com/erigontech/erigon/node/gointerfaces/sentryproto"
	txpoolcfg "github.com/erigontech/erigon/txnprovider/txpool/txpoolcfg"
	gomock "go.uber.org/mock/gomock"
)

// MockPool is a mock of Pool interface.
type MockPool struct {
	ctrl     *gomock.Controller
	recorder *MockPoolMockRecorder
	isgomock struct{}
}

// MockPoolMockRecorder is the mock recorder for MockPool.
type MockPoolMockRecorder struct {
	mock *MockPool
}

// NewMockPool creates a new mock instance.
func NewMockPool(ctrl *gomock.Controller) *MockPool {
	mock := &MockPool{ctrl: ctrl}
	mock.recorder = &MockPoolMockRecorder{mock}
	return mock
}

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

// AddLocalTxns mocks base method.
func (m *MockPool) AddLocalTxns(ctx context.Context, newTxns TxnSlots) ([]txpoolcfg.DiscardReason, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLocalTxns", ctx, newTxns)
	ret0, _ := ret[0].([]txpoolcfg.DiscardReason)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddLocalTxns indicates an expected call of AddLocalTxns.
func (mr *MockPoolMockRecorder) AddLocalTxns(ctx, newTxns any) *MockPoolAddLocalTxnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLocalTxns", reflect.TypeOf((*MockPool)(nil).AddLocalTxns), ctx, newTxns)
	return &MockPoolAddLocalTxnsCall{Call: call}
}

// MockPoolAddLocalTxnsCall wrap *gomock.Call
type MockPoolAddLocalTxnsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolAddLocalTxnsCall) Return(arg0 []txpoolcfg.DiscardReason, arg1 error) *MockPoolAddLocalTxnsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolAddLocalTxnsCall) Do(f func(context.Context, TxnSlots) ([]txpoolcfg.DiscardReason, error)) *MockPoolAddLocalTxnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolAddLocalTxnsCall) DoAndReturn(f func(context.Context, TxnSlots) ([]txpoolcfg.DiscardReason, error)) *MockPoolAddLocalTxnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddNewGoodPeer mocks base method.
func (m *MockPool) AddNewGoodPeer(peerID PeerID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddNewGoodPeer", peerID)
}

// AddNewGoodPeer indicates an expected call of AddNewGoodPeer.
func (mr *MockPoolMockRecorder) AddNewGoodPeer(peerID any) *MockPoolAddNewGoodPeerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewGoodPeer", reflect.TypeOf((*MockPool)(nil).AddNewGoodPeer), peerID)
	return &MockPoolAddNewGoodPeerCall{Call: call}
}

// MockPoolAddNewGoodPeerCall wrap *gomock.Call
type MockPoolAddNewGoodPeerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolAddNewGoodPeerCall) Return() *MockPoolAddNewGoodPeerCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolAddNewGoodPeerCall) Do(f func(PeerID)) *MockPoolAddNewGoodPeerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolAddNewGoodPeerCall) DoAndReturn(f func(PeerID)) *MockPoolAddNewGoodPeerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddRemoteTxns mocks base method.
func (m *MockPool) AddRemoteTxns(ctx context.Context, newTxns TxnSlots, peerID PeerID, sentry sentryproto.SentryClient) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddRemoteTxns", ctx, newTxns, peerID, sentry)
}

// AddRemoteTxns indicates an expected call of AddRemoteTxns.
func (mr *MockPoolMockRecorder) AddRemoteTxns(ctx, newTxns, peerID, sentry any) *MockPoolAddRemoteTxnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRemoteTxns", reflect.TypeOf((*MockPool)(nil).AddRemoteTxns), ctx, newTxns, peerID, sentry)
	return &MockPoolAddRemoteTxnsCall{Call: call}
}

// MockPoolAddRemoteTxnsCall wrap *gomock.Call
type MockPoolAddRemoteTxnsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolAddRemoteTxnsCall) Return() *MockPoolAddRemoteTxnsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolAddRemoteTxnsCall) Do(f func(context.Context, TxnSlots, PeerID, sentryproto.SentryClient)) *MockPoolAddRemoteTxnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolAddRemoteTxnsCall) DoAndReturn(f func(context.Context, TxnSlots, PeerID, sentryproto.SentryClient)) *MockPoolAddRemoteTxnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FilterKnownIdHashes mocks base method.
func (m *MockPool) FilterKnownIdHashes(tx kv.Tx, hashes Hashes) (Hashes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FilterKnownIdHashes", tx, hashes)
	ret0, _ := ret[0].(Hashes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FilterKnownIdHashes indicates an expected call of FilterKnownIdHashes.
func (mr *MockPoolMockRecorder) FilterKnownIdHashes(tx, hashes any) *MockPoolFilterKnownIdHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterKnownIdHashes", reflect.TypeOf((*MockPool)(nil).FilterKnownIdHashes), tx, hashes)
	return &MockPoolFilterKnownIdHashesCall{Call: call}
}

// MockPoolFilterKnownIdHashesCall wrap *gomock.Call
type MockPoolFilterKnownIdHashesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolFilterKnownIdHashesCall) Return(unknownHashes Hashes, err error) *MockPoolFilterKnownIdHashesCall {
	c.Call = c.Call.Return(unknownHashes, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolFilterKnownIdHashesCall) Do(f func(kv.Tx, Hashes) (Hashes, error)) *MockPoolFilterKnownIdHashesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolFilterKnownIdHashesCall) DoAndReturn(f func(kv.Tx, Hashes) (Hashes, error)) *MockPoolFilterKnownIdHashesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetBlobs mocks base method.
func (m *MockPool) GetBlobs(blobhashes []common.Hash) []PoolBlobBundle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlobs", blobhashes)
	ret0, _ := ret[0].([]PoolBlobBundle)
	return ret0
}

// GetBlobs indicates an expected call of GetBlobs.
func (mr *MockPoolMockRecorder) GetBlobs(blobhashes any) *MockPoolGetBlobsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlobs", reflect.TypeOf((*MockPool)(nil).GetBlobs), blobhashes)
	return &MockPoolGetBlobsCall{Call: call}
}

// MockPoolGetBlobsCall wrap *gomock.Call
type MockPoolGetBlobsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolGetBlobsCall) Return(arg0 []PoolBlobBundle) *MockPoolGetBlobsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolGetBlobsCall) Do(f func([]common.Hash) []PoolBlobBundle) *MockPoolGetBlobsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolGetBlobsCall) DoAndReturn(f func([]common.Hash) []PoolBlobBundle) *MockPoolGetBlobsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRlp mocks base method.
func (m *MockPool) GetRlp(tx kv.Tx, hash []byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRlp", tx, hash)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRlp indicates an expected call of GetRlp.
func (mr *MockPoolMockRecorder) GetRlp(tx, hash any) *MockPoolGetRlpCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRlp", reflect.TypeOf((*MockPool)(nil).GetRlp), tx, hash)
	return &MockPoolGetRlpCall{Call: call}
}

// MockPoolGetRlpCall wrap *gomock.Call
type MockPoolGetRlpCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolGetRlpCall) Return(arg0 []byte, arg1 error) *MockPoolGetRlpCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolGetRlpCall) Do(f func(kv.Tx, []byte) ([]byte, error)) *MockPoolGetRlpCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolGetRlpCall) DoAndReturn(f func(kv.Tx, []byte) ([]byte, error)) *MockPoolGetRlpCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IdHashKnown mocks base method.
func (m *MockPool) IdHashKnown(tx kv.Tx, hash []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IdHashKnown", tx, hash)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IdHashKnown indicates an expected call of IdHashKnown.
func (mr *MockPoolMockRecorder) IdHashKnown(tx, hash any) *MockPoolIdHashKnownCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdHashKnown", reflect.TypeOf((*MockPool)(nil).IdHashKnown), tx, hash)
	return &MockPoolIdHashKnownCall{Call: call}
}

// MockPoolIdHashKnownCall wrap *gomock.Call
type MockPoolIdHashKnownCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolIdHashKnownCall) Return(arg0 bool, arg1 error) *MockPoolIdHashKnownCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolIdHashKnownCall) Do(f func(kv.Tx, []byte) (bool, error)) *MockPoolIdHashKnownCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolIdHashKnownCall) DoAndReturn(f func(kv.Tx, []byte) (bool, error)) *MockPoolIdHashKnownCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OnNewBlock mocks base method.
func (m *MockPool) OnNewBlock(ctx context.Context, stateChanges *remoteproto.StateChangeBatch, unwindTxns, unwindBlobTxns, minedTxns TxnSlots) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnNewBlock", ctx, stateChanges, unwindTxns, unwindBlobTxns, minedTxns)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnNewBlock indicates an expected call of OnNewBlock.
func (mr *MockPoolMockRecorder) OnNewBlock(ctx, stateChanges, unwindTxns, unwindBlobTxns, minedTxns any) *MockPoolOnNewBlockCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnNewBlock", reflect.TypeOf((*MockPool)(nil).OnNewBlock), ctx, stateChanges, unwindTxns, unwindBlobTxns, minedTxns)
	return &MockPoolOnNewBlockCall{Call: call}
}

// MockPoolOnNewBlockCall wrap *gomock.Call
type MockPoolOnNewBlockCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolOnNewBlockCall) Return(arg0 error) *MockPoolOnNewBlockCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolOnNewBlockCall) Do(f func(context.Context, *remoteproto.StateChangeBatch, TxnSlots, TxnSlots, TxnSlots) error) *MockPoolOnNewBlockCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolOnNewBlockCall) DoAndReturn(f func(context.Context, *remoteproto.StateChangeBatch, TxnSlots, TxnSlots, TxnSlots) error) *MockPoolOnNewBlockCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Started indicates an expected call of Started.
func (mr *MockPoolMockRecorder) Started() *MockPoolStartedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Started", reflect.TypeOf((*MockPool)(nil).Started))
	return &MockPoolStartedCall{Call: call}
}

// MockPoolStartedCall wrap *gomock.Call
type MockPoolStartedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolStartedCall) Return(arg0 bool) *MockPoolStartedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolStartedCall) Do(f func() bool) *MockPoolStartedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolStartedCall) DoAndReturn(f func() bool) *MockPoolStartedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ValidateSerializedTxn mocks base method.
func (m *MockPool) ValidateSerializedTxn(serializedTxn []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateSerializedTxn", serializedTxn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateSerializedTxn indicates an expected call of ValidateSerializedTxn.
func (mr *MockPoolMockRecorder) ValidateSerializedTxn(serializedTxn any) *MockPoolValidateSerializedTxnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateSerializedTxn", reflect.TypeOf((*MockPool)(nil).ValidateSerializedTxn), serializedTxn)
	return &MockPoolValidateSerializedTxnCall{Call: call}
}

// MockPoolValidateSerializedTxnCall wrap *gomock.Call
type MockPoolValidateSerializedTxnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolValidateSerializedTxnCall) Return(arg0 error) *MockPoolValidateSerializedTxnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolValidateSerializedTxnCall) Do(f func([]byte) error) *MockPoolValidateSerializedTxnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolValidateSerializedTxnCall) DoAndReturn(f func([]byte) error) *MockPoolValidateSerializedTxnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
