etherman.generated.go

// Code generated by mockery v2.40.1. DO NOT EDIT.

package mocks

import (
	big "math/big"

	bind "github.com/ethereum/go-ethereum/accounts/abi/bind"
	common "github.com/ethereum/go-ethereum/common"

	context "context"

	etherman "github.com/0xPolygon/cdk-data-availability/etherman"

	event "github.com/ethereum/go-ethereum/event"

	mock "github.com/stretchr/testify/mock"

	polygonvalidium "github.com/0xPolygon/cdk-data-availability/etherman/smartcontracts/etrog/polygonvalidium"

	types "github.com/ethereum/go-ethereum/core/types"
)

// Etherman is an autogenerated mock type for the Etherman type
type Etherman struct {
	mock.Mock
}

type Etherman_Expecter struct {
	mock *mock.Mock
}

func (_m *Etherman) EXPECT() *Etherman_Expecter {
	return &Etherman_Expecter{mock: &_m.Mock}
}

// FilterSequenceBatches provides a mock function with given fields: opts, numBatch
func (_m *Etherman) FilterSequenceBatches(opts *bind.FilterOpts, numBatch []uint64) (*polygonvalidium.PolygonvalidiumSequenceBatchesIterator, error) {
	ret := _m.Called(opts, numBatch)

	if len(ret) == 0 {
		panic("no return value specified for FilterSequenceBatches")
	}

	var r0 *polygonvalidium.PolygonvalidiumSequenceBatchesIterator
	var r1 error
	if rf, ok := ret.Get(0).(func(*bind.FilterOpts, []uint64) (*polygonvalidium.PolygonvalidiumSequenceBatchesIterator, error)); ok {
		return rf(opts, numBatch)
	}
	if rf, ok := ret.Get(0).(func(*bind.FilterOpts, []uint64) *polygonvalidium.PolygonvalidiumSequenceBatchesIterator); ok {
		r0 = rf(opts, numBatch)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*polygonvalidium.PolygonvalidiumSequenceBatchesIterator)
		}
	}

	if rf, ok := ret.Get(1).(func(*bind.FilterOpts, []uint64) error); ok {
		r1 = rf(opts, numBatch)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_FilterSequenceBatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterSequenceBatches'
type Etherman_FilterSequenceBatches_Call struct {
	*mock.Call
}

// FilterSequenceBatches is a helper method to define mock.On call
//   - opts *bind.FilterOpts
//   - numBatch []uint64
func (_e *Etherman_Expecter) FilterSequenceBatches(opts interface{}, numBatch interface{}) *Etherman_FilterSequenceBatches_Call {
	return &Etherman_FilterSequenceBatches_Call{Call: _e.mock.On("FilterSequenceBatches", opts, numBatch)}
}

func (_c *Etherman_FilterSequenceBatches_Call) Run(run func(opts *bind.FilterOpts, numBatch []uint64)) *Etherman_FilterSequenceBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*bind.FilterOpts), args[1].([]uint64))
	})
	return _c
}

func (_c *Etherman_FilterSequenceBatches_Call) Return(_a0 *polygonvalidium.PolygonvalidiumSequenceBatchesIterator, _a1 error) *Etherman_FilterSequenceBatches_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_FilterSequenceBatches_Call) RunAndReturn(run func(*bind.FilterOpts, []uint64) (*polygonvalidium.PolygonvalidiumSequenceBatchesIterator, error)) *Etherman_FilterSequenceBatches_Call {
	_c.Call.Return(run)
	return _c
}

// GetCurrentDataCommittee provides a mock function with given fields:
func (_m *Etherman) GetCurrentDataCommittee() (*etherman.DataCommittee, error) {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetCurrentDataCommittee")
	}

	var r0 *etherman.DataCommittee
	var r1 error
	if rf, ok := ret.Get(0).(func() (*etherman.DataCommittee, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *etherman.DataCommittee); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*etherman.DataCommittee)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_GetCurrentDataCommittee_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentDataCommittee'
type Etherman_GetCurrentDataCommittee_Call struct {
	*mock.Call
}

// GetCurrentDataCommittee is a helper method to define mock.On call
func (_e *Etherman_Expecter) GetCurrentDataCommittee() *Etherman_GetCurrentDataCommittee_Call {
	return &Etherman_GetCurrentDataCommittee_Call{Call: _e.mock.On("GetCurrentDataCommittee")}
}

func (_c *Etherman_GetCurrentDataCommittee_Call) Run(run func()) *Etherman_GetCurrentDataCommittee_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Etherman_GetCurrentDataCommittee_Call) Return(_a0 *etherman.DataCommittee, _a1 error) *Etherman_GetCurrentDataCommittee_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_GetCurrentDataCommittee_Call) RunAndReturn(run func() (*etherman.DataCommittee, error)) *Etherman_GetCurrentDataCommittee_Call {
	_c.Call.Return(run)
	return _c
}

// GetCurrentDataCommitteeMembers provides a mock function with given fields:
func (_m *Etherman) GetCurrentDataCommitteeMembers() ([]etherman.DataCommitteeMember, error) {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetCurrentDataCommitteeMembers")
	}

	var r0 []etherman.DataCommitteeMember
	var r1 error
	if rf, ok := ret.Get(0).(func() ([]etherman.DataCommitteeMember, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() []etherman.DataCommitteeMember); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]etherman.DataCommitteeMember)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_GetCurrentDataCommitteeMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentDataCommitteeMembers'
type Etherman_GetCurrentDataCommitteeMembers_Call struct {
	*mock.Call
}

// GetCurrentDataCommitteeMembers is a helper method to define mock.On call
func (_e *Etherman_Expecter) GetCurrentDataCommitteeMembers() *Etherman_GetCurrentDataCommitteeMembers_Call {
	return &Etherman_GetCurrentDataCommitteeMembers_Call{Call: _e.mock.On("GetCurrentDataCommitteeMembers")}
}

func (_c *Etherman_GetCurrentDataCommitteeMembers_Call) Run(run func()) *Etherman_GetCurrentDataCommitteeMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Etherman_GetCurrentDataCommitteeMembers_Call) Return(_a0 []etherman.DataCommitteeMember, _a1 error) *Etherman_GetCurrentDataCommitteeMembers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_GetCurrentDataCommitteeMembers_Call) RunAndReturn(run func() ([]etherman.DataCommitteeMember, error)) *Etherman_GetCurrentDataCommitteeMembers_Call {
	_c.Call.Return(run)
	return _c
}

// GetTx provides a mock function with given fields: ctx, txHash
func (_m *Etherman) GetTx(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) {
	ret := _m.Called(ctx, txHash)

	if len(ret) == 0 {
		panic("no return value specified for GetTx")
	}

	var r0 *types.Transaction
	var r1 bool
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (*types.Transaction, bool, error)); ok {
		return rf(ctx, txHash)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) *types.Transaction); ok {
		r0 = rf(ctx, txHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Transaction)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash) bool); ok {
		r1 = rf(ctx, txHash)
	} else {
		r1 = ret.Get(1).(bool)
	}

	if rf, ok := ret.Get(2).(func(context.Context, common.Hash) error); ok {
		r2 = rf(ctx, txHash)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// Etherman_GetTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTx'
type Etherman_GetTx_Call struct {
	*mock.Call
}

// GetTx is a helper method to define mock.On call
//   - ctx context.Context
//   - txHash common.Hash
func (_e *Etherman_Expecter) GetTx(ctx interface{}, txHash interface{}) *Etherman_GetTx_Call {
	return &Etherman_GetTx_Call{Call: _e.mock.On("GetTx", ctx, txHash)}
}

func (_c *Etherman_GetTx_Call) Run(run func(ctx context.Context, txHash common.Hash)) *Etherman_GetTx_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash))
	})
	return _c
}

func (_c *Etherman_GetTx_Call) Return(_a0 *types.Transaction, _a1 bool, _a2 error) *Etherman_GetTx_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *Etherman_GetTx_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Transaction, bool, error)) *Etherman_GetTx_Call {
	_c.Call.Return(run)
	return _c
}

// HeaderByNumber provides a mock function with given fields: ctx, number
func (_m *Etherman) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
	ret := _m.Called(ctx, number)

	if len(ret) == 0 {
		panic("no return value specified for HeaderByNumber")
	}

	var r0 *types.Header
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *big.Int) (*types.Header, error)); ok {
		return rf(ctx, number)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *big.Int) *types.Header); ok {
		r0 = rf(ctx, number)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Header)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *big.Int) error); ok {
		r1 = rf(ctx, number)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_HeaderByNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByNumber'
type Etherman_HeaderByNumber_Call struct {
	*mock.Call
}

// HeaderByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - number *big.Int
func (_e *Etherman_Expecter) HeaderByNumber(ctx interface{}, number interface{}) *Etherman_HeaderByNumber_Call {
	return &Etherman_HeaderByNumber_Call{Call: _e.mock.On("HeaderByNumber", ctx, number)}
}

func (_c *Etherman_HeaderByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *Etherman_HeaderByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*big.Int))
	})
	return _c
}

func (_c *Etherman_HeaderByNumber_Call) Return(_a0 *types.Header, _a1 error) *Etherman_HeaderByNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_HeaderByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Header, error)) *Etherman_HeaderByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// TrustedSequencer provides a mock function with given fields:
func (_m *Etherman) TrustedSequencer() (common.Address, error) {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for TrustedSequencer")
	}

	var r0 common.Address
	var r1 error
	if rf, ok := ret.Get(0).(func() (common.Address, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() common.Address); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Address)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_TrustedSequencer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrustedSequencer'
type Etherman_TrustedSequencer_Call struct {
	*mock.Call
}

// TrustedSequencer is a helper method to define mock.On call
func (_e *Etherman_Expecter) TrustedSequencer() *Etherman_TrustedSequencer_Call {
	return &Etherman_TrustedSequencer_Call{Call: _e.mock.On("TrustedSequencer")}
}

func (_c *Etherman_TrustedSequencer_Call) Run(run func()) *Etherman_TrustedSequencer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Etherman_TrustedSequencer_Call) Return(_a0 common.Address, _a1 error) *Etherman_TrustedSequencer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_TrustedSequencer_Call) RunAndReturn(run func() (common.Address, error)) *Etherman_TrustedSequencer_Call {
	_c.Call.Return(run)
	return _c
}

// TrustedSequencerURL provides a mock function with given fields:
func (_m *Etherman) TrustedSequencerURL() (string, error) {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for TrustedSequencerURL")
	}

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func() (string, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_TrustedSequencerURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrustedSequencerURL'
type Etherman_TrustedSequencerURL_Call struct {
	*mock.Call
}

// TrustedSequencerURL is a helper method to define mock.On call
func (_e *Etherman_Expecter) TrustedSequencerURL() *Etherman_TrustedSequencerURL_Call {
	return &Etherman_TrustedSequencerURL_Call{Call: _e.mock.On("TrustedSequencerURL")}
}

func (_c *Etherman_TrustedSequencerURL_Call) Run(run func()) *Etherman_TrustedSequencerURL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Etherman_TrustedSequencerURL_Call) Return(_a0 string, _a1 error) *Etherman_TrustedSequencerURL_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_TrustedSequencerURL_Call) RunAndReturn(run func() (string, error)) *Etherman_TrustedSequencerURL_Call {
	_c.Call.Return(run)
	return _c
}

// WatchSetTrustedSequencer provides a mock function with given fields: ctx, events
func (_m *Etherman) WatchSetTrustedSequencer(ctx context.Context, events chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer) (event.Subscription, error) {
	ret := _m.Called(ctx, events)

	if len(ret) == 0 {
		panic("no return value specified for WatchSetTrustedSequencer")
	}

	var r0 event.Subscription
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer) (event.Subscription, error)); ok {
		return rf(ctx, events)
	}
	if rf, ok := ret.Get(0).(func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer) event.Subscription); ok {
		r0 = rf(ctx, events)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(event.Subscription)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer) error); ok {
		r1 = rf(ctx, events)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_WatchSetTrustedSequencer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchSetTrustedSequencer'
type Etherman_WatchSetTrustedSequencer_Call struct {
	*mock.Call
}

// WatchSetTrustedSequencer is a helper method to define mock.On call
//   - ctx context.Context
//   - events chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer
func (_e *Etherman_Expecter) WatchSetTrustedSequencer(ctx interface{}, events interface{}) *Etherman_WatchSetTrustedSequencer_Call {
	return &Etherman_WatchSetTrustedSequencer_Call{Call: _e.mock.On("WatchSetTrustedSequencer", ctx, events)}
}

func (_c *Etherman_WatchSetTrustedSequencer_Call) Run(run func(ctx context.Context, events chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer)) *Etherman_WatchSetTrustedSequencer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer))
	})
	return _c
}

func (_c *Etherman_WatchSetTrustedSequencer_Call) Return(_a0 event.Subscription, _a1 error) *Etherman_WatchSetTrustedSequencer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_WatchSetTrustedSequencer_Call) RunAndReturn(run func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencer) (event.Subscription, error)) *Etherman_WatchSetTrustedSequencer_Call {
	_c.Call.Return(run)
	return _c
}

// WatchSetTrustedSequencerURL provides a mock function with given fields: ctx, events
func (_m *Etherman) WatchSetTrustedSequencerURL(ctx context.Context, events chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL) (event.Subscription, error) {
	ret := _m.Called(ctx, events)

	if len(ret) == 0 {
		panic("no return value specified for WatchSetTrustedSequencerURL")
	}

	var r0 event.Subscription
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL) (event.Subscription, error)); ok {
		return rf(ctx, events)
	}
	if rf, ok := ret.Get(0).(func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL) event.Subscription); ok {
		r0 = rf(ctx, events)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(event.Subscription)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL) error); ok {
		r1 = rf(ctx, events)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Etherman_WatchSetTrustedSequencerURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchSetTrustedSequencerURL'
type Etherman_WatchSetTrustedSequencerURL_Call struct {
	*mock.Call
}

// WatchSetTrustedSequencerURL is a helper method to define mock.On call
//   - ctx context.Context
//   - events chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL
func (_e *Etherman_Expecter) WatchSetTrustedSequencerURL(ctx interface{}, events interface{}) *Etherman_WatchSetTrustedSequencerURL_Call {
	return &Etherman_WatchSetTrustedSequencerURL_Call{Call: _e.mock.On("WatchSetTrustedSequencerURL", ctx, events)}
}

func (_c *Etherman_WatchSetTrustedSequencerURL_Call) Run(run func(ctx context.Context, events chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL)) *Etherman_WatchSetTrustedSequencerURL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL))
	})
	return _c
}

func (_c *Etherman_WatchSetTrustedSequencerURL_Call) Return(_a0 event.Subscription, _a1 error) *Etherman_WatchSetTrustedSequencerURL_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Etherman_WatchSetTrustedSequencerURL_Call) RunAndReturn(run func(context.Context, chan *polygonvalidium.PolygonvalidiumSetTrustedSequencerURL) (event.Subscription, error)) *Etherman_WatchSetTrustedSequencerURL_Call {
	_c.Call.Return(run)
	return _c
}

// NewEtherman creates a new instance of Etherman. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewEtherman(t interface {
	mock.TestingT
	Cleanup(func())
}) *Etherman {
	mock := &Etherman{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}