// Copyright 2025 Sonic Operations Ltd
// This file is part of the Sonic Client
//
// Sonic is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Sonic is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Sonic. If not, see <http://www.gnu.org/licenses/>.

// Code generated by MockGen. DO NOT EDIT.
// Source: protocol.go
//
// Generated by this command:
//
//	mockgen -source=protocol.go -package=gossip -destination=protocol_mock.go
//

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

import (
	big "math/big"
	reflect "reflect"

	evmcore "github.com/0xsoniclabs/sonic/evmcore"
	common "github.com/ethereum/go-ethereum/common"
	types "github.com/ethereum/go-ethereum/core/types"
	event "github.com/ethereum/go-ethereum/event"
	gomock "go.uber.org/mock/gomock"
)

// MockTxPool is a mock of TxPool interface.
type MockTxPool struct {
	ctrl     *gomock.Controller
	recorder *MockTxPoolMockRecorder
}

// MockTxPoolMockRecorder is the mock recorder for MockTxPool.
type MockTxPoolMockRecorder struct {
	mock *MockTxPool
}

// NewMockTxPool creates a new mock instance.
func NewMockTxPool(ctrl *gomock.Controller) *MockTxPool {
	mock := &MockTxPool{ctrl: ctrl}
	mock.recorder = &MockTxPoolMockRecorder{mock}
	return mock
}

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

// AddLocal mocks base method.
func (m *MockTxPool) AddLocal(tx *types.Transaction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLocal", tx)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLocal indicates an expected call of AddLocal.
func (mr *MockTxPoolMockRecorder) AddLocal(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLocal", reflect.TypeOf((*MockTxPool)(nil).AddLocal), tx)
}

// AddLocals mocks base method.
func (m *MockTxPool) AddLocals(txs []*types.Transaction) []error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLocals", txs)
	ret0, _ := ret[0].([]error)
	return ret0
}

// AddLocals indicates an expected call of AddLocals.
func (mr *MockTxPoolMockRecorder) AddLocals(txs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLocals", reflect.TypeOf((*MockTxPool)(nil).AddLocals), txs)
}

// AddRemotes mocks base method.
func (m *MockTxPool) AddRemotes(arg0 []*types.Transaction) []error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRemotes", arg0)
	ret0, _ := ret[0].([]error)
	return ret0
}

// AddRemotes indicates an expected call of AddRemotes.
func (mr *MockTxPoolMockRecorder) AddRemotes(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRemotes", reflect.TypeOf((*MockTxPool)(nil).AddRemotes), arg0)
}

// Content mocks base method.
func (m *MockTxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Content")
	ret0, _ := ret[0].(map[common.Address]types.Transactions)
	ret1, _ := ret[1].(map[common.Address]types.Transactions)
	return ret0, ret1
}

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

// ContentFrom mocks base method.
func (m *MockTxPool) ContentFrom(addr common.Address) (types.Transactions, types.Transactions) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContentFrom", addr)
	ret0, _ := ret[0].(types.Transactions)
	ret1, _ := ret[1].(types.Transactions)
	return ret0, ret1
}

// ContentFrom indicates an expected call of ContentFrom.
func (mr *MockTxPoolMockRecorder) ContentFrom(addr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentFrom", reflect.TypeOf((*MockTxPool)(nil).ContentFrom), addr)
}

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

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

// Get mocks base method.
func (m *MockTxPool) Get(arg0 common.Hash) *types.Transaction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(*types.Transaction)
	return ret0
}

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

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

// Has indicates an expected call of Has.
func (mr *MockTxPoolMockRecorder) Has(hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockTxPool)(nil).Has), hash)
}

// MinTip mocks base method.
func (m *MockTxPool) MinTip() *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MinTip")
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

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

// Nonce mocks base method.
func (m *MockTxPool) Nonce(addr common.Address) uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Nonce", addr)
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Nonce indicates an expected call of Nonce.
func (mr *MockTxPoolMockRecorder) Nonce(addr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nonce", reflect.TypeOf((*MockTxPool)(nil).Nonce), addr)
}

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

// OnlyNotExisting indicates an expected call of OnlyNotExisting.
func (mr *MockTxPoolMockRecorder) OnlyNotExisting(hashes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnlyNotExisting", reflect.TypeOf((*MockTxPool)(nil).OnlyNotExisting), hashes)
}

// Pending mocks base method.
func (m *MockTxPool) Pending(enforceTips bool) (map[common.Address]types.Transactions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pending", enforceTips)
	ret0, _ := ret[0].(map[common.Address]types.Transactions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pending indicates an expected call of Pending.
func (mr *MockTxPoolMockRecorder) Pending(enforceTips any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockTxPool)(nil).Pending), enforceTips)
}

// SampleHashes mocks base method.
func (m *MockTxPool) SampleHashes(max int) []common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SampleHashes", max)
	ret0, _ := ret[0].([]common.Hash)
	return ret0
}

// SampleHashes indicates an expected call of SampleHashes.
func (mr *MockTxPoolMockRecorder) SampleHashes(max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SampleHashes", reflect.TypeOf((*MockTxPool)(nil).SampleHashes), max)
}

// Stats mocks base method.
func (m *MockTxPool) 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 *MockTxPoolMockRecorder) Stats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockTxPool)(nil).Stats))
}

// Stop mocks base method.
func (m *MockTxPool) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}

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

// SubscribeNewTxsNotify mocks base method.
func (m *MockTxPool) SubscribeNewTxsNotify(arg0 chan<- evmcore.NewTxsNotify) event.Subscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeNewTxsNotify", arg0)
	ret0, _ := ret[0].(event.Subscription)
	return ret0
}

// SubscribeNewTxsNotify indicates an expected call of SubscribeNewTxsNotify.
func (mr *MockTxPoolMockRecorder) SubscribeNewTxsNotify(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeNewTxsNotify", reflect.TypeOf((*MockTxPool)(nil).SubscribeNewTxsNotify), arg0)
}
