// Code generated by MockGen. DO NOT EDIT.
// Source: accounts/abi/bind/backend.go
//
// Generated by this command:
//
//	mockgen -source=accounts/abi/bind/backend.go -package=bind -destination=accounts/abi/bind/backend_mock.go
//

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

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

	ethereum "github.com/autonity/autonity"
	common "github.com/autonity/autonity/common"
	types "github.com/autonity/autonity/core/types"
	gomock "go.uber.org/mock/gomock"
)

// MockContractCaller is a mock of ContractCaller interface.
type MockContractCaller struct {
	ctrl     *gomock.Controller
	recorder *MockContractCallerMockRecorder
	isgomock struct{}
}

// MockContractCallerMockRecorder is the mock recorder for MockContractCaller.
type MockContractCallerMockRecorder struct {
	mock *MockContractCaller
}

// NewMockContractCaller creates a new mock instance.
func NewMockContractCaller(ctrl *gomock.Controller) *MockContractCaller {
	mock := &MockContractCaller{ctrl: ctrl}
	mock.recorder = &MockContractCallerMockRecorder{mock}
	return mock
}

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

// CallContract mocks base method.
func (m *MockContractCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallContract", ctx, call, blockNumber)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CallContract indicates an expected call of CallContract.
func (mr *MockContractCallerMockRecorder) CallContract(ctx, call, blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockContractCaller)(nil).CallContract), ctx, call, blockNumber)
}

// CodeAt mocks base method.
func (m *MockContractCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CodeAt indicates an expected call of CodeAt.
func (mr *MockContractCallerMockRecorder) CodeAt(ctx, contract, blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockContractCaller)(nil).CodeAt), ctx, contract, blockNumber)
}

// MockPendingContractCaller is a mock of PendingContractCaller interface.
type MockPendingContractCaller struct {
	ctrl     *gomock.Controller
	recorder *MockPendingContractCallerMockRecorder
	isgomock struct{}
}

// MockPendingContractCallerMockRecorder is the mock recorder for MockPendingContractCaller.
type MockPendingContractCallerMockRecorder struct {
	mock *MockPendingContractCaller
}

// NewMockPendingContractCaller creates a new mock instance.
func NewMockPendingContractCaller(ctrl *gomock.Controller) *MockPendingContractCaller {
	mock := &MockPendingContractCaller{ctrl: ctrl}
	mock.recorder = &MockPendingContractCallerMockRecorder{mock}
	return mock
}

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

// PendingCallContract mocks base method.
func (m *MockPendingContractCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingCallContract", ctx, call)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingCallContract indicates an expected call of PendingCallContract.
func (mr *MockPendingContractCallerMockRecorder) PendingCallContract(ctx, call any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCallContract", reflect.TypeOf((*MockPendingContractCaller)(nil).PendingCallContract), ctx, call)
}

// PendingCodeAt mocks base method.
func (m *MockPendingContractCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingCodeAt", ctx, contract)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingCodeAt indicates an expected call of PendingCodeAt.
func (mr *MockPendingContractCallerMockRecorder) PendingCodeAt(ctx, contract any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockPendingContractCaller)(nil).PendingCodeAt), ctx, contract)
}

// MockContractTransactor is a mock of ContractTransactor interface.
type MockContractTransactor struct {
	ctrl     *gomock.Controller
	recorder *MockContractTransactorMockRecorder
	isgomock struct{}
}

// MockContractTransactorMockRecorder is the mock recorder for MockContractTransactor.
type MockContractTransactorMockRecorder struct {
	mock *MockContractTransactor
}

// NewMockContractTransactor creates a new mock instance.
func NewMockContractTransactor(ctrl *gomock.Controller) *MockContractTransactor {
	mock := &MockContractTransactor{ctrl: ctrl}
	mock.recorder = &MockContractTransactorMockRecorder{mock}
	return mock
}

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

// EstimateGas mocks base method.
func (m *MockContractTransactor) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateGas", ctx, call)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimateGas indicates an expected call of EstimateGas.
func (mr *MockContractTransactorMockRecorder) EstimateGas(ctx, call any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockContractTransactor)(nil).EstimateGas), ctx, call)
}

// HeaderByNumber mocks base method.
func (m *MockContractTransactor) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeaderByNumber", ctx, number)
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeaderByNumber indicates an expected call of HeaderByNumber.
func (mr *MockContractTransactorMockRecorder) HeaderByNumber(ctx, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockContractTransactor)(nil).HeaderByNumber), ctx, number)
}

// PendingCodeAt mocks base method.
func (m *MockContractTransactor) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingCodeAt", ctx, account)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingCodeAt indicates an expected call of PendingCodeAt.
func (mr *MockContractTransactorMockRecorder) PendingCodeAt(ctx, account any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockContractTransactor)(nil).PendingCodeAt), ctx, account)
}

// PendingNonceAt mocks base method.
func (m *MockContractTransactor) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingNonceAt", ctx, account)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingNonceAt indicates an expected call of PendingNonceAt.
func (mr *MockContractTransactorMockRecorder) PendingNonceAt(ctx, account any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingNonceAt", reflect.TypeOf((*MockContractTransactor)(nil).PendingNonceAt), ctx, account)
}

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

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

// SuggestGasPrice mocks base method.
func (m *MockContractTransactor) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuggestGasPrice", ctx)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SuggestGasPrice indicates an expected call of SuggestGasPrice.
func (mr *MockContractTransactorMockRecorder) SuggestGasPrice(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasPrice", reflect.TypeOf((*MockContractTransactor)(nil).SuggestGasPrice), ctx)
}

// SuggestGasTipCap mocks base method.
func (m *MockContractTransactor) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuggestGasTipCap", ctx)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SuggestGasTipCap indicates an expected call of SuggestGasTipCap.
func (mr *MockContractTransactorMockRecorder) SuggestGasTipCap(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasTipCap", reflect.TypeOf((*MockContractTransactor)(nil).SuggestGasTipCap), ctx)
}

// MockContractFilterer is a mock of ContractFilterer interface.
type MockContractFilterer struct {
	ctrl     *gomock.Controller
	recorder *MockContractFiltererMockRecorder
	isgomock struct{}
}

// MockContractFiltererMockRecorder is the mock recorder for MockContractFilterer.
type MockContractFiltererMockRecorder struct {
	mock *MockContractFilterer
}

// NewMockContractFilterer creates a new mock instance.
func NewMockContractFilterer(ctrl *gomock.Controller) *MockContractFilterer {
	mock := &MockContractFilterer{ctrl: ctrl}
	mock.recorder = &MockContractFiltererMockRecorder{mock}
	return mock
}

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

// FilterLogs mocks base method.
func (m *MockContractFilterer) FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FilterLogs", ctx, query)
	ret0, _ := ret[0].([]types.Log)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FilterLogs indicates an expected call of FilterLogs.
func (mr *MockContractFiltererMockRecorder) FilterLogs(ctx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockContractFilterer)(nil).FilterLogs), ctx, query)
}

// SubscribeFilterLogs mocks base method.
func (m *MockContractFilterer) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeFilterLogs", ctx, query, ch)
	ret0, _ := ret[0].(ethereum.Subscription)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscribeFilterLogs indicates an expected call of SubscribeFilterLogs.
func (mr *MockContractFiltererMockRecorder) SubscribeFilterLogs(ctx, query, ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockContractFilterer)(nil).SubscribeFilterLogs), ctx, query, ch)
}

// MockDeployBackend is a mock of DeployBackend interface.
type MockDeployBackend struct {
	ctrl     *gomock.Controller
	recorder *MockDeployBackendMockRecorder
	isgomock struct{}
}

// MockDeployBackendMockRecorder is the mock recorder for MockDeployBackend.
type MockDeployBackendMockRecorder struct {
	mock *MockDeployBackend
}

// NewMockDeployBackend creates a new mock instance.
func NewMockDeployBackend(ctrl *gomock.Controller) *MockDeployBackend {
	mock := &MockDeployBackend{ctrl: ctrl}
	mock.recorder = &MockDeployBackendMockRecorder{mock}
	return mock
}

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

// CodeAt mocks base method.
func (m *MockDeployBackend) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CodeAt", ctx, account, blockNumber)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CodeAt indicates an expected call of CodeAt.
func (mr *MockDeployBackendMockRecorder) CodeAt(ctx, account, blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockDeployBackend)(nil).CodeAt), ctx, account, blockNumber)
}

// TransactionReceipt mocks base method.
func (m *MockDeployBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactionReceipt", ctx, txHash)
	ret0, _ := ret[0].(*types.Receipt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactionReceipt indicates an expected call of TransactionReceipt.
func (mr *MockDeployBackendMockRecorder) TransactionReceipt(ctx, txHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockDeployBackend)(nil).TransactionReceipt), ctx, txHash)
}

// MockContractBackend is a mock of ContractBackend interface.
type MockContractBackend struct {
	ctrl     *gomock.Controller
	recorder *MockContractBackendMockRecorder
	isgomock struct{}
}

// MockContractBackendMockRecorder is the mock recorder for MockContractBackend.
type MockContractBackendMockRecorder struct {
	mock *MockContractBackend
}

// NewMockContractBackend creates a new mock instance.
func NewMockContractBackend(ctrl *gomock.Controller) *MockContractBackend {
	mock := &MockContractBackend{ctrl: ctrl}
	mock.recorder = &MockContractBackendMockRecorder{mock}
	return mock
}

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

// CallContract mocks base method.
func (m *MockContractBackend) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallContract", ctx, call, blockNumber)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CallContract indicates an expected call of CallContract.
func (mr *MockContractBackendMockRecorder) CallContract(ctx, call, blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockContractBackend)(nil).CallContract), ctx, call, blockNumber)
}

// CodeAt mocks base method.
func (m *MockContractBackend) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CodeAt indicates an expected call of CodeAt.
func (mr *MockContractBackendMockRecorder) CodeAt(ctx, contract, blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockContractBackend)(nil).CodeAt), ctx, contract, blockNumber)
}

// EstimateGas mocks base method.
func (m *MockContractBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateGas", ctx, call)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimateGas indicates an expected call of EstimateGas.
func (mr *MockContractBackendMockRecorder) EstimateGas(ctx, call any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockContractBackend)(nil).EstimateGas), ctx, call)
}

// FilterLogs mocks base method.
func (m *MockContractBackend) FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FilterLogs", ctx, query)
	ret0, _ := ret[0].([]types.Log)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FilterLogs indicates an expected call of FilterLogs.
func (mr *MockContractBackendMockRecorder) FilterLogs(ctx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockContractBackend)(nil).FilterLogs), ctx, query)
}

// HeaderByNumber mocks base method.
func (m *MockContractBackend) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeaderByNumber", ctx, number)
	ret0, _ := ret[0].(*types.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeaderByNumber indicates an expected call of HeaderByNumber.
func (mr *MockContractBackendMockRecorder) HeaderByNumber(ctx, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockContractBackend)(nil).HeaderByNumber), ctx, number)
}

// PendingCodeAt mocks base method.
func (m *MockContractBackend) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingCodeAt", ctx, account)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingCodeAt indicates an expected call of PendingCodeAt.
func (mr *MockContractBackendMockRecorder) PendingCodeAt(ctx, account any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockContractBackend)(nil).PendingCodeAt), ctx, account)
}

// PendingNonceAt mocks base method.
func (m *MockContractBackend) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingNonceAt", ctx, account)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingNonceAt indicates an expected call of PendingNonceAt.
func (mr *MockContractBackendMockRecorder) PendingNonceAt(ctx, account any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingNonceAt", reflect.TypeOf((*MockContractBackend)(nil).PendingNonceAt), ctx, account)
}

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

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

// SubscribeFilterLogs mocks base method.
func (m *MockContractBackend) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeFilterLogs", ctx, query, ch)
	ret0, _ := ret[0].(ethereum.Subscription)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscribeFilterLogs indicates an expected call of SubscribeFilterLogs.
func (mr *MockContractBackendMockRecorder) SubscribeFilterLogs(ctx, query, ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockContractBackend)(nil).SubscribeFilterLogs), ctx, query, ch)
}

// SuggestGasPrice mocks base method.
func (m *MockContractBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuggestGasPrice", ctx)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SuggestGasPrice indicates an expected call of SuggestGasPrice.
func (mr *MockContractBackendMockRecorder) SuggestGasPrice(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasPrice", reflect.TypeOf((*MockContractBackend)(nil).SuggestGasPrice), ctx)
}

// SuggestGasTipCap mocks base method.
func (m *MockContractBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuggestGasTipCap", ctx)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SuggestGasTipCap indicates an expected call of SuggestGasTipCap.
func (mr *MockContractBackendMockRecorder) SuggestGasTipCap(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasTipCap", reflect.TypeOf((*MockContractBackend)(nil).SuggestGasTipCap), ctx)
}
