// Code generated by mockery. DO NOT EDIT.

package mock_syncinterfaces

import (
	context "context"

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

	executor "github.com/0xPolygonHermez/zkevm-node/state/runtime/executor"

	metrics "github.com/0xPolygonHermez/zkevm-node/state/metrics"

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

	pgx "github.com/jackc/pgx/v4"

	state "github.com/0xPolygonHermez/zkevm-node/state"

	time "time"

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

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

type StateFullInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *StateFullInterface) EXPECT() *StateFullInterface_Expecter {
	return &StateFullInterface_Expecter{mock: &_m.Mock}
}

// AddAccumulatedInputHash provides a mock function with given fields: ctx, batchNum, accInputHash, dbTx
func (_m *StateFullInterface) AddAccumulatedInputHash(ctx context.Context, batchNum uint64, accInputHash common.Hash, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, batchNum, accInputHash, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, common.Hash, pgx.Tx) error); ok {
		r0 = rf(ctx, batchNum, accInputHash, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddAccumulatedInputHash is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNum uint64
//   - accInputHash common.Hash
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddAccumulatedInputHash(ctx interface{}, batchNum interface{}, accInputHash interface{}, dbTx interface{}) *StateFullInterface_AddAccumulatedInputHash_Call {
	return &StateFullInterface_AddAccumulatedInputHash_Call{Call: _e.mock.On("AddAccumulatedInputHash", ctx, batchNum, accInputHash, dbTx)}
}

func (_c *StateFullInterface_AddAccumulatedInputHash_Call) Run(run func(ctx context.Context, batchNum uint64, accInputHash common.Hash, dbTx pgx.Tx)) *StateFullInterface_AddAccumulatedInputHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(common.Hash), args[3].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddAccumulatedInputHash_Call) Return(_a0 error) *StateFullInterface_AddAccumulatedInputHash_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddAccumulatedInputHash_Call) RunAndReturn(run func(context.Context, uint64, common.Hash, pgx.Tx) error) *StateFullInterface_AddAccumulatedInputHash_Call {
	_c.Call.Return(run)
	return _c
}

// AddBlobInner provides a mock function with given fields: ctx, blobInner, dbTx
func (_m *StateFullInterface) AddBlobInner(ctx context.Context, blobInner *state.BlobInner, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, blobInner, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.BlobInner, pgx.Tx) error); ok {
		r0 = rf(ctx, blobInner, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddBlobInner is a helper method to define mock.On call
//   - ctx context.Context
//   - blobInner *state.BlobInner
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddBlobInner(ctx interface{}, blobInner interface{}, dbTx interface{}) *StateFullInterface_AddBlobInner_Call {
	return &StateFullInterface_AddBlobInner_Call{Call: _e.mock.On("AddBlobInner", ctx, blobInner, dbTx)}
}

func (_c *StateFullInterface_AddBlobInner_Call) Run(run func(ctx context.Context, blobInner *state.BlobInner, dbTx pgx.Tx)) *StateFullInterface_AddBlobInner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.BlobInner), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddBlobInner_Call) Return(_a0 error) *StateFullInterface_AddBlobInner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddBlobInner_Call) RunAndReturn(run func(context.Context, *state.BlobInner, pgx.Tx) error) *StateFullInterface_AddBlobInner_Call {
	_c.Call.Return(run)
	return _c
}

// AddBlobSequence provides a mock function with given fields: ctx, blobSequence, dbTx
func (_m *StateFullInterface) AddBlobSequence(ctx context.Context, blobSequence *state.BlobSequence, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, blobSequence, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.BlobSequence, pgx.Tx) error); ok {
		r0 = rf(ctx, blobSequence, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddBlobSequence is a helper method to define mock.On call
//   - ctx context.Context
//   - blobSequence *state.BlobSequence
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddBlobSequence(ctx interface{}, blobSequence interface{}, dbTx interface{}) *StateFullInterface_AddBlobSequence_Call {
	return &StateFullInterface_AddBlobSequence_Call{Call: _e.mock.On("AddBlobSequence", ctx, blobSequence, dbTx)}
}

func (_c *StateFullInterface_AddBlobSequence_Call) Run(run func(ctx context.Context, blobSequence *state.BlobSequence, dbTx pgx.Tx)) *StateFullInterface_AddBlobSequence_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.BlobSequence), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddBlobSequence_Call) Return(_a0 error) *StateFullInterface_AddBlobSequence_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddBlobSequence_Call) RunAndReturn(run func(context.Context, *state.BlobSequence, pgx.Tx) error) *StateFullInterface_AddBlobSequence_Call {
	_c.Call.Return(run)
	return _c
}

// AddBlock provides a mock function with given fields: ctx, block, dbTx
func (_m *StateFullInterface) AddBlock(ctx context.Context, block *state.Block, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, block, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.Block, pgx.Tx) error); ok {
		r0 = rf(ctx, block, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - block *state.Block
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddBlock(ctx interface{}, block interface{}, dbTx interface{}) *StateFullInterface_AddBlock_Call {
	return &StateFullInterface_AddBlock_Call{Call: _e.mock.On("AddBlock", ctx, block, dbTx)}
}

func (_c *StateFullInterface_AddBlock_Call) Run(run func(ctx context.Context, block *state.Block, dbTx pgx.Tx)) *StateFullInterface_AddBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.Block), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddBlock_Call) Return(_a0 error) *StateFullInterface_AddBlock_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddBlock_Call) RunAndReturn(run func(context.Context, *state.Block, pgx.Tx) error) *StateFullInterface_AddBlock_Call {
	_c.Call.Return(run)
	return _c
}

// AddForcedBatch provides a mock function with given fields: ctx, forcedBatch, dbTx
func (_m *StateFullInterface) AddForcedBatch(ctx context.Context, forcedBatch *state.ForcedBatch, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, forcedBatch, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.ForcedBatch, pgx.Tx) error); ok {
		r0 = rf(ctx, forcedBatch, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddForcedBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - forcedBatch *state.ForcedBatch
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddForcedBatch(ctx interface{}, forcedBatch interface{}, dbTx interface{}) *StateFullInterface_AddForcedBatch_Call {
	return &StateFullInterface_AddForcedBatch_Call{Call: _e.mock.On("AddForcedBatch", ctx, forcedBatch, dbTx)}
}

func (_c *StateFullInterface_AddForcedBatch_Call) Run(run func(ctx context.Context, forcedBatch *state.ForcedBatch, dbTx pgx.Tx)) *StateFullInterface_AddForcedBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.ForcedBatch), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddForcedBatch_Call) Return(_a0 error) *StateFullInterface_AddForcedBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddForcedBatch_Call) RunAndReturn(run func(context.Context, *state.ForcedBatch, pgx.Tx) error) *StateFullInterface_AddForcedBatch_Call {
	_c.Call.Return(run)
	return _c
}

// AddForkIDInterval provides a mock function with given fields: ctx, newForkID, dbTx
func (_m *StateFullInterface) AddForkIDInterval(ctx context.Context, newForkID state.ForkIDInterval, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, newForkID, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ForkIDInterval, pgx.Tx) error); ok {
		r0 = rf(ctx, newForkID, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddForkIDInterval is a helper method to define mock.On call
//   - ctx context.Context
//   - newForkID state.ForkIDInterval
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddForkIDInterval(ctx interface{}, newForkID interface{}, dbTx interface{}) *StateFullInterface_AddForkIDInterval_Call {
	return &StateFullInterface_AddForkIDInterval_Call{Call: _e.mock.On("AddForkIDInterval", ctx, newForkID, dbTx)}
}

func (_c *StateFullInterface_AddForkIDInterval_Call) Run(run func(ctx context.Context, newForkID state.ForkIDInterval, dbTx pgx.Tx)) *StateFullInterface_AddForkIDInterval_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ForkIDInterval), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddForkIDInterval_Call) Return(_a0 error) *StateFullInterface_AddForkIDInterval_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddForkIDInterval_Call) RunAndReturn(run func(context.Context, state.ForkIDInterval, pgx.Tx) error) *StateFullInterface_AddForkIDInterval_Call {
	_c.Call.Return(run)
	return _c
}

// AddGlobalExitRoot provides a mock function with given fields: ctx, exitRoot, dbTx
func (_m *StateFullInterface) AddGlobalExitRoot(ctx context.Context, exitRoot *state.GlobalExitRoot, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, exitRoot, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.GlobalExitRoot, pgx.Tx) error); ok {
		r0 = rf(ctx, exitRoot, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddGlobalExitRoot is a helper method to define mock.On call
//   - ctx context.Context
//   - exitRoot *state.GlobalExitRoot
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddGlobalExitRoot(ctx interface{}, exitRoot interface{}, dbTx interface{}) *StateFullInterface_AddGlobalExitRoot_Call {
	return &StateFullInterface_AddGlobalExitRoot_Call{Call: _e.mock.On("AddGlobalExitRoot", ctx, exitRoot, dbTx)}
}

func (_c *StateFullInterface_AddGlobalExitRoot_Call) Run(run func(ctx context.Context, exitRoot *state.GlobalExitRoot, dbTx pgx.Tx)) *StateFullInterface_AddGlobalExitRoot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.GlobalExitRoot), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddGlobalExitRoot_Call) Return(_a0 error) *StateFullInterface_AddGlobalExitRoot_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddGlobalExitRoot_Call) RunAndReturn(run func(context.Context, *state.GlobalExitRoot, pgx.Tx) error) *StateFullInterface_AddGlobalExitRoot_Call {
	_c.Call.Return(run)
	return _c
}

// AddL1InfoTreeLeaf provides a mock function with given fields: ctx, L1InfoTreeLeaf, dbTx
func (_m *StateFullInterface) AddL1InfoTreeLeaf(ctx context.Context, L1InfoTreeLeaf *state.L1InfoTreeLeaf, dbTx pgx.Tx) (*state.L1InfoTreeExitRootStorageEntry, error) {
	ret := _m.Called(ctx, L1InfoTreeLeaf, dbTx)

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

	var r0 *state.L1InfoTreeExitRootStorageEntry
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) (*state.L1InfoTreeExitRootStorageEntry, error)); ok {
		return rf(ctx, L1InfoTreeLeaf, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) *state.L1InfoTreeExitRootStorageEntry); ok {
		r0 = rf(ctx, L1InfoTreeLeaf, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.L1InfoTreeExitRootStorageEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) error); ok {
		r1 = rf(ctx, L1InfoTreeLeaf, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddL1InfoTreeLeaf is a helper method to define mock.On call
//   - ctx context.Context
//   - L1InfoTreeLeaf *state.L1InfoTreeLeaf
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddL1InfoTreeLeaf(ctx interface{}, L1InfoTreeLeaf interface{}, dbTx interface{}) *StateFullInterface_AddL1InfoTreeLeaf_Call {
	return &StateFullInterface_AddL1InfoTreeLeaf_Call{Call: _e.mock.On("AddL1InfoTreeLeaf", ctx, L1InfoTreeLeaf, dbTx)}
}

func (_c *StateFullInterface_AddL1InfoTreeLeaf_Call) Run(run func(ctx context.Context, L1InfoTreeLeaf *state.L1InfoTreeLeaf, dbTx pgx.Tx)) *StateFullInterface_AddL1InfoTreeLeaf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.L1InfoTreeLeaf), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddL1InfoTreeLeaf_Call) Return(_a0 *state.L1InfoTreeExitRootStorageEntry, _a1 error) *StateFullInterface_AddL1InfoTreeLeaf_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_AddL1InfoTreeLeaf_Call) RunAndReturn(run func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) (*state.L1InfoTreeExitRootStorageEntry, error)) *StateFullInterface_AddL1InfoTreeLeaf_Call {
	_c.Call.Return(run)
	return _c
}

// AddL1InfoTreeRecursiveLeaf provides a mock function with given fields: ctx, L1InfoTreeLeaf, dbTx
func (_m *StateFullInterface) AddL1InfoTreeRecursiveLeaf(ctx context.Context, L1InfoTreeLeaf *state.L1InfoTreeLeaf, dbTx pgx.Tx) (*state.L1InfoTreeExitRootStorageEntry, error) {
	ret := _m.Called(ctx, L1InfoTreeLeaf, dbTx)

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

	var r0 *state.L1InfoTreeExitRootStorageEntry
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) (*state.L1InfoTreeExitRootStorageEntry, error)); ok {
		return rf(ctx, L1InfoTreeLeaf, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) *state.L1InfoTreeExitRootStorageEntry); ok {
		r0 = rf(ctx, L1InfoTreeLeaf, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.L1InfoTreeExitRootStorageEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) error); ok {
		r1 = rf(ctx, L1InfoTreeLeaf, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddL1InfoTreeRecursiveLeaf is a helper method to define mock.On call
//   - ctx context.Context
//   - L1InfoTreeLeaf *state.L1InfoTreeLeaf
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddL1InfoTreeRecursiveLeaf(ctx interface{}, L1InfoTreeLeaf interface{}, dbTx interface{}) *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call {
	return &StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call{Call: _e.mock.On("AddL1InfoTreeRecursiveLeaf", ctx, L1InfoTreeLeaf, dbTx)}
}

func (_c *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call) Run(run func(ctx context.Context, L1InfoTreeLeaf *state.L1InfoTreeLeaf, dbTx pgx.Tx)) *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.L1InfoTreeLeaf), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call) Return(_a0 *state.L1InfoTreeExitRootStorageEntry, _a1 error) *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call) RunAndReturn(run func(context.Context, *state.L1InfoTreeLeaf, pgx.Tx) (*state.L1InfoTreeExitRootStorageEntry, error)) *StateFullInterface_AddL1InfoTreeRecursiveLeaf_Call {
	_c.Call.Return(run)
	return _c
}

// AddSequence provides a mock function with given fields: ctx, sequence, dbTx
func (_m *StateFullInterface) AddSequence(ctx context.Context, sequence state.Sequence, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, sequence, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, state.Sequence, pgx.Tx) error); ok {
		r0 = rf(ctx, sequence, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddSequence is a helper method to define mock.On call
//   - ctx context.Context
//   - sequence state.Sequence
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddSequence(ctx interface{}, sequence interface{}, dbTx interface{}) *StateFullInterface_AddSequence_Call {
	return &StateFullInterface_AddSequence_Call{Call: _e.mock.On("AddSequence", ctx, sequence, dbTx)}
}

func (_c *StateFullInterface_AddSequence_Call) Run(run func(ctx context.Context, sequence state.Sequence, dbTx pgx.Tx)) *StateFullInterface_AddSequence_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.Sequence), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddSequence_Call) Return(_a0 error) *StateFullInterface_AddSequence_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddSequence_Call) RunAndReturn(run func(context.Context, state.Sequence, pgx.Tx) error) *StateFullInterface_AddSequence_Call {
	_c.Call.Return(run)
	return _c
}

// AddTrustedReorg provides a mock function with given fields: ctx, trustedReorg, dbTx
func (_m *StateFullInterface) AddTrustedReorg(ctx context.Context, trustedReorg *state.TrustedReorg, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, trustedReorg, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.TrustedReorg, pgx.Tx) error); ok {
		r0 = rf(ctx, trustedReorg, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddTrustedReorg is a helper method to define mock.On call
//   - ctx context.Context
//   - trustedReorg *state.TrustedReorg
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddTrustedReorg(ctx interface{}, trustedReorg interface{}, dbTx interface{}) *StateFullInterface_AddTrustedReorg_Call {
	return &StateFullInterface_AddTrustedReorg_Call{Call: _e.mock.On("AddTrustedReorg", ctx, trustedReorg, dbTx)}
}

func (_c *StateFullInterface_AddTrustedReorg_Call) Run(run func(ctx context.Context, trustedReorg *state.TrustedReorg, dbTx pgx.Tx)) *StateFullInterface_AddTrustedReorg_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.TrustedReorg), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddTrustedReorg_Call) Return(_a0 error) *StateFullInterface_AddTrustedReorg_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddTrustedReorg_Call) RunAndReturn(run func(context.Context, *state.TrustedReorg, pgx.Tx) error) *StateFullInterface_AddTrustedReorg_Call {
	_c.Call.Return(run)
	return _c
}

// AddVerifiedBatch provides a mock function with given fields: ctx, verifiedBatch, dbTx
func (_m *StateFullInterface) AddVerifiedBatch(ctx context.Context, verifiedBatch *state.VerifiedBatch, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, verifiedBatch, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.VerifiedBatch, pgx.Tx) error); ok {
		r0 = rf(ctx, verifiedBatch, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddVerifiedBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - verifiedBatch *state.VerifiedBatch
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddVerifiedBatch(ctx interface{}, verifiedBatch interface{}, dbTx interface{}) *StateFullInterface_AddVerifiedBatch_Call {
	return &StateFullInterface_AddVerifiedBatch_Call{Call: _e.mock.On("AddVerifiedBatch", ctx, verifiedBatch, dbTx)}
}

func (_c *StateFullInterface_AddVerifiedBatch_Call) Run(run func(ctx context.Context, verifiedBatch *state.VerifiedBatch, dbTx pgx.Tx)) *StateFullInterface_AddVerifiedBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.VerifiedBatch), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddVerifiedBatch_Call) Return(_a0 error) *StateFullInterface_AddVerifiedBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddVerifiedBatch_Call) RunAndReturn(run func(context.Context, *state.VerifiedBatch, pgx.Tx) error) *StateFullInterface_AddVerifiedBatch_Call {
	_c.Call.Return(run)
	return _c
}

// AddVirtualBatch provides a mock function with given fields: ctx, virtualBatch, dbTx
func (_m *StateFullInterface) AddVirtualBatch(ctx context.Context, virtualBatch *state.VirtualBatch, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, virtualBatch, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *state.VirtualBatch, pgx.Tx) error); ok {
		r0 = rf(ctx, virtualBatch, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddVirtualBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - virtualBatch *state.VirtualBatch
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) AddVirtualBatch(ctx interface{}, virtualBatch interface{}, dbTx interface{}) *StateFullInterface_AddVirtualBatch_Call {
	return &StateFullInterface_AddVirtualBatch_Call{Call: _e.mock.On("AddVirtualBatch", ctx, virtualBatch, dbTx)}
}

func (_c *StateFullInterface_AddVirtualBatch_Call) Run(run func(ctx context.Context, virtualBatch *state.VirtualBatch, dbTx pgx.Tx)) *StateFullInterface_AddVirtualBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*state.VirtualBatch), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_AddVirtualBatch_Call) Return(_a0 error) *StateFullInterface_AddVirtualBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_AddVirtualBatch_Call) RunAndReturn(run func(context.Context, *state.VirtualBatch, pgx.Tx) error) *StateFullInterface_AddVirtualBatch_Call {
	_c.Call.Return(run)
	return _c
}

// BeginStateTransaction provides a mock function with given fields: ctx
func (_m *StateFullInterface) BeginStateTransaction(ctx context.Context) (pgx.Tx, error) {
	ret := _m.Called(ctx)

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

	var r0 pgx.Tx
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (pgx.Tx, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) pgx.Tx); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(pgx.Tx)
		}
	}

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

	return r0, r1
}

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

// BeginStateTransaction is a helper method to define mock.On call
//   - ctx context.Context
func (_e *StateFullInterface_Expecter) BeginStateTransaction(ctx interface{}) *StateFullInterface_BeginStateTransaction_Call {
	return &StateFullInterface_BeginStateTransaction_Call{Call: _e.mock.On("BeginStateTransaction", ctx)}
}

func (_c *StateFullInterface_BeginStateTransaction_Call) Run(run func(ctx context.Context)) *StateFullInterface_BeginStateTransaction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *StateFullInterface_BeginStateTransaction_Call) Return(_a0 pgx.Tx, _a1 error) *StateFullInterface_BeginStateTransaction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_BeginStateTransaction_Call) RunAndReturn(run func(context.Context) (pgx.Tx, error)) *StateFullInterface_BeginStateTransaction_Call {
	_c.Call.Return(run)
	return _c
}

// CloseBatch provides a mock function with given fields: ctx, receipt, dbTx
func (_m *StateFullInterface) CloseBatch(ctx context.Context, receipt state.ProcessingReceipt, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, receipt, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingReceipt, pgx.Tx) error); ok {
		r0 = rf(ctx, receipt, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CloseBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - receipt state.ProcessingReceipt
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) CloseBatch(ctx interface{}, receipt interface{}, dbTx interface{}) *StateFullInterface_CloseBatch_Call {
	return &StateFullInterface_CloseBatch_Call{Call: _e.mock.On("CloseBatch", ctx, receipt, dbTx)}
}

func (_c *StateFullInterface_CloseBatch_Call) Run(run func(ctx context.Context, receipt state.ProcessingReceipt, dbTx pgx.Tx)) *StateFullInterface_CloseBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessingReceipt), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_CloseBatch_Call) Return(_a0 error) *StateFullInterface_CloseBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_CloseBatch_Call) RunAndReturn(run func(context.Context, state.ProcessingReceipt, pgx.Tx) error) *StateFullInterface_CloseBatch_Call {
	_c.Call.Return(run)
	return _c
}

// ExecuteBatch provides a mock function with given fields: ctx, batch, updateMerkleTree, dbTx
func (_m *StateFullInterface) ExecuteBatch(ctx context.Context, batch state.Batch, updateMerkleTree bool, dbTx pgx.Tx) (*executor.ProcessBatchResponse, error) {
	ret := _m.Called(ctx, batch, updateMerkleTree, dbTx)

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

	var r0 *executor.ProcessBatchResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, state.Batch, bool, pgx.Tx) (*executor.ProcessBatchResponse, error)); ok {
		return rf(ctx, batch, updateMerkleTree, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.Batch, bool, pgx.Tx) *executor.ProcessBatchResponse); ok {
		r0 = rf(ctx, batch, updateMerkleTree, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*executor.ProcessBatchResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.Batch, bool, pgx.Tx) error); ok {
		r1 = rf(ctx, batch, updateMerkleTree, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ExecuteBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - batch state.Batch
//   - updateMerkleTree bool
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) ExecuteBatch(ctx interface{}, batch interface{}, updateMerkleTree interface{}, dbTx interface{}) *StateFullInterface_ExecuteBatch_Call {
	return &StateFullInterface_ExecuteBatch_Call{Call: _e.mock.On("ExecuteBatch", ctx, batch, updateMerkleTree, dbTx)}
}

func (_c *StateFullInterface_ExecuteBatch_Call) Run(run func(ctx context.Context, batch state.Batch, updateMerkleTree bool, dbTx pgx.Tx)) *StateFullInterface_ExecuteBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.Batch), args[2].(bool), args[3].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_ExecuteBatch_Call) Return(_a0 *executor.ProcessBatchResponse, _a1 error) *StateFullInterface_ExecuteBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_ExecuteBatch_Call) RunAndReturn(run func(context.Context, state.Batch, bool, pgx.Tx) (*executor.ProcessBatchResponse, error)) *StateFullInterface_ExecuteBatch_Call {
	_c.Call.Return(run)
	return _c
}

// ExecuteBatchV2 provides a mock function with given fields: ctx, batch, L1InfoTreeRoot, l1InfoTreeData, timestampLimit, updateMerkleTree, skipVerifyL1InfoRoot, forcedBlockHashL1, dbTx
func (_m *StateFullInterface) ExecuteBatchV2(ctx context.Context, batch state.Batch, L1InfoTreeRoot common.Hash, l1InfoTreeData map[uint32]state.L1DataV2, timestampLimit time.Time, updateMerkleTree bool, skipVerifyL1InfoRoot uint32, forcedBlockHashL1 *common.Hash, dbTx pgx.Tx) (*executor.ProcessBatchResponseV2, error) {
	ret := _m.Called(ctx, batch, L1InfoTreeRoot, l1InfoTreeData, timestampLimit, updateMerkleTree, skipVerifyL1InfoRoot, forcedBlockHashL1, dbTx)

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

	var r0 *executor.ProcessBatchResponseV2
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, state.Batch, common.Hash, map[uint32]state.L1DataV2, time.Time, bool, uint32, *common.Hash, pgx.Tx) (*executor.ProcessBatchResponseV2, error)); ok {
		return rf(ctx, batch, L1InfoTreeRoot, l1InfoTreeData, timestampLimit, updateMerkleTree, skipVerifyL1InfoRoot, forcedBlockHashL1, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.Batch, common.Hash, map[uint32]state.L1DataV2, time.Time, bool, uint32, *common.Hash, pgx.Tx) *executor.ProcessBatchResponseV2); ok {
		r0 = rf(ctx, batch, L1InfoTreeRoot, l1InfoTreeData, timestampLimit, updateMerkleTree, skipVerifyL1InfoRoot, forcedBlockHashL1, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*executor.ProcessBatchResponseV2)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.Batch, common.Hash, map[uint32]state.L1DataV2, time.Time, bool, uint32, *common.Hash, pgx.Tx) error); ok {
		r1 = rf(ctx, batch, L1InfoTreeRoot, l1InfoTreeData, timestampLimit, updateMerkleTree, skipVerifyL1InfoRoot, forcedBlockHashL1, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ExecuteBatchV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - batch state.Batch
//   - L1InfoTreeRoot common.Hash
//   - l1InfoTreeData map[uint32]state.L1DataV2
//   - timestampLimit time.Time
//   - updateMerkleTree bool
//   - skipVerifyL1InfoRoot uint32
//   - forcedBlockHashL1 *common.Hash
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) ExecuteBatchV2(ctx interface{}, batch interface{}, L1InfoTreeRoot interface{}, l1InfoTreeData interface{}, timestampLimit interface{}, updateMerkleTree interface{}, skipVerifyL1InfoRoot interface{}, forcedBlockHashL1 interface{}, dbTx interface{}) *StateFullInterface_ExecuteBatchV2_Call {
	return &StateFullInterface_ExecuteBatchV2_Call{Call: _e.mock.On("ExecuteBatchV2", ctx, batch, L1InfoTreeRoot, l1InfoTreeData, timestampLimit, updateMerkleTree, skipVerifyL1InfoRoot, forcedBlockHashL1, dbTx)}
}

func (_c *StateFullInterface_ExecuteBatchV2_Call) Run(run func(ctx context.Context, batch state.Batch, L1InfoTreeRoot common.Hash, l1InfoTreeData map[uint32]state.L1DataV2, timestampLimit time.Time, updateMerkleTree bool, skipVerifyL1InfoRoot uint32, forcedBlockHashL1 *common.Hash, dbTx pgx.Tx)) *StateFullInterface_ExecuteBatchV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.Batch), args[2].(common.Hash), args[3].(map[uint32]state.L1DataV2), args[4].(time.Time), args[5].(bool), args[6].(uint32), args[7].(*common.Hash), args[8].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_ExecuteBatchV2_Call) Return(_a0 *executor.ProcessBatchResponseV2, _a1 error) *StateFullInterface_ExecuteBatchV2_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_ExecuteBatchV2_Call) RunAndReturn(run func(context.Context, state.Batch, common.Hash, map[uint32]state.L1DataV2, time.Time, bool, uint32, *common.Hash, pgx.Tx) (*executor.ProcessBatchResponseV2, error)) *StateFullInterface_ExecuteBatchV2_Call {
	_c.Call.Return(run)
	return _c
}

// GetBatchByNumber provides a mock function with given fields: ctx, batchNumber, dbTx
func (_m *StateFullInterface) GetBatchByNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*state.Batch, error) {
	ret := _m.Called(ctx, batchNumber, dbTx)

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

	var r0 *state.Batch
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.Batch, error)); ok {
		return rf(ctx, batchNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.Batch); ok {
		r0 = rf(ctx, batchNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.Batch)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, batchNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetBatchByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetBatchByNumber(ctx interface{}, batchNumber interface{}, dbTx interface{}) *StateFullInterface_GetBatchByNumber_Call {
	return &StateFullInterface_GetBatchByNumber_Call{Call: _e.mock.On("GetBatchByNumber", ctx, batchNumber, dbTx)}
}

func (_c *StateFullInterface_GetBatchByNumber_Call) Run(run func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetBatchByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetBatchByNumber_Call) Return(_a0 *state.Batch, _a1 error) *StateFullInterface_GetBatchByNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetBatchByNumber_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.Batch, error)) *StateFullInterface_GetBatchByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlockByNumber provides a mock function with given fields: ctx, blockNumber, dbTx
func (_m *StateFullInterface) GetBlockByNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (*state.Block, error) {
	ret := _m.Called(ctx, blockNumber, dbTx)

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

	var r0 *state.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.Block, error)); ok {
		return rf(ctx, blockNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.Block); ok {
		r0 = rf(ctx, blockNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, blockNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetBlockByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - blockNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetBlockByNumber(ctx interface{}, blockNumber interface{}, dbTx interface{}) *StateFullInterface_GetBlockByNumber_Call {
	return &StateFullInterface_GetBlockByNumber_Call{Call: _e.mock.On("GetBlockByNumber", ctx, blockNumber, dbTx)}
}

func (_c *StateFullInterface_GetBlockByNumber_Call) Run(run func(ctx context.Context, blockNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetBlockByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetBlockByNumber_Call) Return(_a0 *state.Block, _a1 error) *StateFullInterface_GetBlockByNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetBlockByNumber_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.Block, error)) *StateFullInterface_GetBlockByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetExitRootByGlobalExitRoot provides a mock function with given fields: ctx, ger, dbTx
func (_m *StateFullInterface) GetExitRootByGlobalExitRoot(ctx context.Context, ger common.Hash, dbTx pgx.Tx) (*state.GlobalExitRoot, error) {
	ret := _m.Called(ctx, ger, dbTx)

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

	var r0 *state.GlobalExitRoot
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash, pgx.Tx) (*state.GlobalExitRoot, error)); ok {
		return rf(ctx, ger, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash, pgx.Tx) *state.GlobalExitRoot); ok {
		r0 = rf(ctx, ger, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.GlobalExitRoot)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash, pgx.Tx) error); ok {
		r1 = rf(ctx, ger, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetExitRootByGlobalExitRoot is a helper method to define mock.On call
//   - ctx context.Context
//   - ger common.Hash
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetExitRootByGlobalExitRoot(ctx interface{}, ger interface{}, dbTx interface{}) *StateFullInterface_GetExitRootByGlobalExitRoot_Call {
	return &StateFullInterface_GetExitRootByGlobalExitRoot_Call{Call: _e.mock.On("GetExitRootByGlobalExitRoot", ctx, ger, dbTx)}
}

func (_c *StateFullInterface_GetExitRootByGlobalExitRoot_Call) Run(run func(ctx context.Context, ger common.Hash, dbTx pgx.Tx)) *StateFullInterface_GetExitRootByGlobalExitRoot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetExitRootByGlobalExitRoot_Call) Return(_a0 *state.GlobalExitRoot, _a1 error) *StateFullInterface_GetExitRootByGlobalExitRoot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetExitRootByGlobalExitRoot_Call) RunAndReturn(run func(context.Context, common.Hash, pgx.Tx) (*state.GlobalExitRoot, error)) *StateFullInterface_GetExitRootByGlobalExitRoot_Call {
	_c.Call.Return(run)
	return _c
}

// GetFirstUncheckedBlock provides a mock function with given fields: ctx, fromBlockNumber, dbTx
func (_m *StateFullInterface) GetFirstUncheckedBlock(ctx context.Context, fromBlockNumber uint64, dbTx pgx.Tx) (*state.Block, error) {
	ret := _m.Called(ctx, fromBlockNumber, dbTx)

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

	var r0 *state.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.Block, error)); ok {
		return rf(ctx, fromBlockNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.Block); ok {
		r0 = rf(ctx, fromBlockNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, fromBlockNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFirstUncheckedBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - fromBlockNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetFirstUncheckedBlock(ctx interface{}, fromBlockNumber interface{}, dbTx interface{}) *StateFullInterface_GetFirstUncheckedBlock_Call {
	return &StateFullInterface_GetFirstUncheckedBlock_Call{Call: _e.mock.On("GetFirstUncheckedBlock", ctx, fromBlockNumber, dbTx)}
}

func (_c *StateFullInterface_GetFirstUncheckedBlock_Call) Run(run func(ctx context.Context, fromBlockNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetFirstUncheckedBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetFirstUncheckedBlock_Call) Return(_a0 *state.Block, _a1 error) *StateFullInterface_GetFirstUncheckedBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetFirstUncheckedBlock_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.Block, error)) *StateFullInterface_GetFirstUncheckedBlock_Call {
	_c.Call.Return(run)
	return _c
}

// GetForkIDByBatchNumber provides a mock function with given fields: batchNumber
func (_m *StateFullInterface) GetForkIDByBatchNumber(batchNumber uint64) uint64 {
	ret := _m.Called(batchNumber)

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

	var r0 uint64
	if rf, ok := ret.Get(0).(func(uint64) uint64); ok {
		r0 = rf(batchNumber)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}

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

// GetForkIDByBatchNumber is a helper method to define mock.On call
//   - batchNumber uint64
func (_e *StateFullInterface_Expecter) GetForkIDByBatchNumber(batchNumber interface{}) *StateFullInterface_GetForkIDByBatchNumber_Call {
	return &StateFullInterface_GetForkIDByBatchNumber_Call{Call: _e.mock.On("GetForkIDByBatchNumber", batchNumber)}
}

func (_c *StateFullInterface_GetForkIDByBatchNumber_Call) Run(run func(batchNumber uint64)) *StateFullInterface_GetForkIDByBatchNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *StateFullInterface_GetForkIDByBatchNumber_Call) Return(_a0 uint64) *StateFullInterface_GetForkIDByBatchNumber_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_GetForkIDByBatchNumber_Call) RunAndReturn(run func(uint64) uint64) *StateFullInterface_GetForkIDByBatchNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetForkIDByBlockNumber provides a mock function with given fields: blockNumber
func (_m *StateFullInterface) GetForkIDByBlockNumber(blockNumber uint64) uint64 {
	ret := _m.Called(blockNumber)

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

	var r0 uint64
	if rf, ok := ret.Get(0).(func(uint64) uint64); ok {
		r0 = rf(blockNumber)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}

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

// GetForkIDByBlockNumber is a helper method to define mock.On call
//   - blockNumber uint64
func (_e *StateFullInterface_Expecter) GetForkIDByBlockNumber(blockNumber interface{}) *StateFullInterface_GetForkIDByBlockNumber_Call {
	return &StateFullInterface_GetForkIDByBlockNumber_Call{Call: _e.mock.On("GetForkIDByBlockNumber", blockNumber)}
}

func (_c *StateFullInterface_GetForkIDByBlockNumber_Call) Run(run func(blockNumber uint64)) *StateFullInterface_GetForkIDByBlockNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *StateFullInterface_GetForkIDByBlockNumber_Call) Return(_a0 uint64) *StateFullInterface_GetForkIDByBlockNumber_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_GetForkIDByBlockNumber_Call) RunAndReturn(run func(uint64) uint64) *StateFullInterface_GetForkIDByBlockNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetForkIDInMemory provides a mock function with given fields: forkId
func (_m *StateFullInterface) GetForkIDInMemory(forkId uint64) *state.ForkIDInterval {
	ret := _m.Called(forkId)

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

	var r0 *state.ForkIDInterval
	if rf, ok := ret.Get(0).(func(uint64) *state.ForkIDInterval); ok {
		r0 = rf(forkId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ForkIDInterval)
		}
	}

	return r0
}

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

// GetForkIDInMemory is a helper method to define mock.On call
//   - forkId uint64
func (_e *StateFullInterface_Expecter) GetForkIDInMemory(forkId interface{}) *StateFullInterface_GetForkIDInMemory_Call {
	return &StateFullInterface_GetForkIDInMemory_Call{Call: _e.mock.On("GetForkIDInMemory", forkId)}
}

func (_c *StateFullInterface_GetForkIDInMemory_Call) Run(run func(forkId uint64)) *StateFullInterface_GetForkIDInMemory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *StateFullInterface_GetForkIDInMemory_Call) Return(_a0 *state.ForkIDInterval) *StateFullInterface_GetForkIDInMemory_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_GetForkIDInMemory_Call) RunAndReturn(run func(uint64) *state.ForkIDInterval) *StateFullInterface_GetForkIDInMemory_Call {
	_c.Call.Return(run)
	return _c
}

// GetForkIDs provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetForkIDs(ctx context.Context, dbTx pgx.Tx) ([]state.ForkIDInterval, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 []state.ForkIDInterval
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) ([]state.ForkIDInterval, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) []state.ForkIDInterval); ok {
		r0 = rf(ctx, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]state.ForkIDInterval)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetForkIDs is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetForkIDs(ctx interface{}, dbTx interface{}) *StateFullInterface_GetForkIDs_Call {
	return &StateFullInterface_GetForkIDs_Call{Call: _e.mock.On("GetForkIDs", ctx, dbTx)}
}

func (_c *StateFullInterface_GetForkIDs_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetForkIDs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetForkIDs_Call) Return(_a0 []state.ForkIDInterval, _a1 error) *StateFullInterface_GetForkIDs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetForkIDs_Call) RunAndReturn(run func(context.Context, pgx.Tx) ([]state.ForkIDInterval, error)) *StateFullInterface_GetForkIDs_Call {
	_c.Call.Return(run)
	return _c
}

// GetL1InfoRecursiveRootLeafByIndex provides a mock function with given fields: ctx, l1InfoTreeIndex, dbTx
func (_m *StateFullInterface) GetL1InfoRecursiveRootLeafByIndex(ctx context.Context, l1InfoTreeIndex uint32, dbTx pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error) {
	ret := _m.Called(ctx, l1InfoTreeIndex, dbTx)

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

	var r0 state.L1InfoTreeExitRootStorageEntry
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint32, pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error)); ok {
		return rf(ctx, l1InfoTreeIndex, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint32, pgx.Tx) state.L1InfoTreeExitRootStorageEntry); ok {
		r0 = rf(ctx, l1InfoTreeIndex, dbTx)
	} else {
		r0 = ret.Get(0).(state.L1InfoTreeExitRootStorageEntry)
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint32, pgx.Tx) error); ok {
		r1 = rf(ctx, l1InfoTreeIndex, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetL1InfoRecursiveRootLeafByIndex is a helper method to define mock.On call
//   - ctx context.Context
//   - l1InfoTreeIndex uint32
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetL1InfoRecursiveRootLeafByIndex(ctx interface{}, l1InfoTreeIndex interface{}, dbTx interface{}) *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call {
	return &StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call{Call: _e.mock.On("GetL1InfoRecursiveRootLeafByIndex", ctx, l1InfoTreeIndex, dbTx)}
}

func (_c *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call) Run(run func(ctx context.Context, l1InfoTreeIndex uint32, dbTx pgx.Tx)) *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint32), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call) Return(_a0 state.L1InfoTreeExitRootStorageEntry, _a1 error) *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call) RunAndReturn(run func(context.Context, uint32, pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error)) *StateFullInterface_GetL1InfoRecursiveRootLeafByIndex_Call {
	_c.Call.Return(run)
	return _c
}

// GetL1InfoRootLeafByL1InfoRoot provides a mock function with given fields: ctx, l1InfoRoot, dbTx
func (_m *StateFullInterface) GetL1InfoRootLeafByL1InfoRoot(ctx context.Context, l1InfoRoot common.Hash, dbTx pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error) {
	ret := _m.Called(ctx, l1InfoRoot, dbTx)

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

	var r0 state.L1InfoTreeExitRootStorageEntry
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash, pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error)); ok {
		return rf(ctx, l1InfoRoot, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash, pgx.Tx) state.L1InfoTreeExitRootStorageEntry); ok {
		r0 = rf(ctx, l1InfoRoot, dbTx)
	} else {
		r0 = ret.Get(0).(state.L1InfoTreeExitRootStorageEntry)
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash, pgx.Tx) error); ok {
		r1 = rf(ctx, l1InfoRoot, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetL1InfoRootLeafByL1InfoRoot is a helper method to define mock.On call
//   - ctx context.Context
//   - l1InfoRoot common.Hash
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetL1InfoRootLeafByL1InfoRoot(ctx interface{}, l1InfoRoot interface{}, dbTx interface{}) *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call {
	return &StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call{Call: _e.mock.On("GetL1InfoRootLeafByL1InfoRoot", ctx, l1InfoRoot, dbTx)}
}

func (_c *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call) Run(run func(ctx context.Context, l1InfoRoot common.Hash, dbTx pgx.Tx)) *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call) Return(_a0 state.L1InfoTreeExitRootStorageEntry, _a1 error) *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call) RunAndReturn(run func(context.Context, common.Hash, pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error)) *StateFullInterface_GetL1InfoRootLeafByL1InfoRoot_Call {
	_c.Call.Return(run)
	return _c
}

// GetL1InfoTreeDataFromBatchL2Data provides a mock function with given fields: ctx, batchL2Data, dbTx
func (_m *StateFullInterface) GetL1InfoTreeDataFromBatchL2Data(ctx context.Context, batchL2Data []byte, dbTx pgx.Tx) (map[uint32]state.L1DataV2, common.Hash, common.Hash, error) {
	ret := _m.Called(ctx, batchL2Data, dbTx)

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

	var r0 map[uint32]state.L1DataV2
	var r1 common.Hash
	var r2 common.Hash
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, []byte, pgx.Tx) (map[uint32]state.L1DataV2, common.Hash, common.Hash, error)); ok {
		return rf(ctx, batchL2Data, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []byte, pgx.Tx) map[uint32]state.L1DataV2); ok {
		r0 = rf(ctx, batchL2Data, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[uint32]state.L1DataV2)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []byte, pgx.Tx) common.Hash); ok {
		r1 = rf(ctx, batchL2Data, dbTx)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(common.Hash)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, []byte, pgx.Tx) common.Hash); ok {
		r2 = rf(ctx, batchL2Data, dbTx)
	} else {
		if ret.Get(2) != nil {
			r2 = ret.Get(2).(common.Hash)
		}
	}

	if rf, ok := ret.Get(3).(func(context.Context, []byte, pgx.Tx) error); ok {
		r3 = rf(ctx, batchL2Data, dbTx)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

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

// GetL1InfoTreeDataFromBatchL2Data is a helper method to define mock.On call
//   - ctx context.Context
//   - batchL2Data []byte
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetL1InfoTreeDataFromBatchL2Data(ctx interface{}, batchL2Data interface{}, dbTx interface{}) *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call {
	return &StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call{Call: _e.mock.On("GetL1InfoTreeDataFromBatchL2Data", ctx, batchL2Data, dbTx)}
}

func (_c *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call) Run(run func(ctx context.Context, batchL2Data []byte, dbTx pgx.Tx)) *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]byte), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call) Return(_a0 map[uint32]state.L1DataV2, _a1 common.Hash, _a2 common.Hash, _a3 error) *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call) RunAndReturn(run func(context.Context, []byte, pgx.Tx) (map[uint32]state.L1DataV2, common.Hash, common.Hash, error)) *StateFullInterface_GetL1InfoTreeDataFromBatchL2Data_Call {
	_c.Call.Return(run)
	return _c
}

// GetL2BlockByNumber provides a mock function with given fields: ctx, blockNumber, dbTx
func (_m *StateFullInterface) GetL2BlockByNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (*state.L2Block, error) {
	ret := _m.Called(ctx, blockNumber, dbTx)

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

	var r0 *state.L2Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.L2Block, error)); ok {
		return rf(ctx, blockNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.L2Block); ok {
		r0 = rf(ctx, blockNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.L2Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, blockNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetL2BlockByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - blockNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetL2BlockByNumber(ctx interface{}, blockNumber interface{}, dbTx interface{}) *StateFullInterface_GetL2BlockByNumber_Call {
	return &StateFullInterface_GetL2BlockByNumber_Call{Call: _e.mock.On("GetL2BlockByNumber", ctx, blockNumber, dbTx)}
}

func (_c *StateFullInterface_GetL2BlockByNumber_Call) Run(run func(ctx context.Context, blockNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetL2BlockByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetL2BlockByNumber_Call) Return(_a0 *state.L2Block, _a1 error) *StateFullInterface_GetL2BlockByNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetL2BlockByNumber_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.L2Block, error)) *StateFullInterface_GetL2BlockByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastBatchNumber provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetLastBatchNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) (uint64, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) uint64); ok {
		r0 = rf(ctx, dbTx)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastBatchNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastBatchNumber(ctx interface{}, dbTx interface{}) *StateFullInterface_GetLastBatchNumber_Call {
	return &StateFullInterface_GetLastBatchNumber_Call{Call: _e.mock.On("GetLastBatchNumber", ctx, dbTx)}
}

func (_c *StateFullInterface_GetLastBatchNumber_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetLastBatchNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastBatchNumber_Call) Return(_a0 uint64, _a1 error) *StateFullInterface_GetLastBatchNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastBatchNumber_Call) RunAndReturn(run func(context.Context, pgx.Tx) (uint64, error)) *StateFullInterface_GetLastBatchNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastBlobSequence provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetLastBlobSequence(ctx context.Context, dbTx pgx.Tx) (*state.BlobSequence, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 *state.BlobSequence
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) (*state.BlobSequence, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) *state.BlobSequence); ok {
		r0 = rf(ctx, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.BlobSequence)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastBlobSequence is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastBlobSequence(ctx interface{}, dbTx interface{}) *StateFullInterface_GetLastBlobSequence_Call {
	return &StateFullInterface_GetLastBlobSequence_Call{Call: _e.mock.On("GetLastBlobSequence", ctx, dbTx)}
}

func (_c *StateFullInterface_GetLastBlobSequence_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetLastBlobSequence_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastBlobSequence_Call) Return(_a0 *state.BlobSequence, _a1 error) *StateFullInterface_GetLastBlobSequence_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastBlobSequence_Call) RunAndReturn(run func(context.Context, pgx.Tx) (*state.BlobSequence, error)) *StateFullInterface_GetLastBlobSequence_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastBlock provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetLastBlock(ctx context.Context, dbTx pgx.Tx) (*state.Block, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 *state.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) (*state.Block, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) *state.Block); ok {
		r0 = rf(ctx, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastBlock(ctx interface{}, dbTx interface{}) *StateFullInterface_GetLastBlock_Call {
	return &StateFullInterface_GetLastBlock_Call{Call: _e.mock.On("GetLastBlock", ctx, dbTx)}
}

func (_c *StateFullInterface_GetLastBlock_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetLastBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastBlock_Call) Return(_a0 *state.Block, _a1 error) *StateFullInterface_GetLastBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastBlock_Call) RunAndReturn(run func(context.Context, pgx.Tx) (*state.Block, error)) *StateFullInterface_GetLastBlock_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastL2BlockByBatchNumber provides a mock function with given fields: ctx, batchNumber, dbTx
func (_m *StateFullInterface) GetLastL2BlockByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*state.L2Block, error) {
	ret := _m.Called(ctx, batchNumber, dbTx)

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

	var r0 *state.L2Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.L2Block, error)); ok {
		return rf(ctx, batchNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.L2Block); ok {
		r0 = rf(ctx, batchNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.L2Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, batchNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastL2BlockByBatchNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastL2BlockByBatchNumber(ctx interface{}, batchNumber interface{}, dbTx interface{}) *StateFullInterface_GetLastL2BlockByBatchNumber_Call {
	return &StateFullInterface_GetLastL2BlockByBatchNumber_Call{Call: _e.mock.On("GetLastL2BlockByBatchNumber", ctx, batchNumber, dbTx)}
}

func (_c *StateFullInterface_GetLastL2BlockByBatchNumber_Call) Run(run func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetLastL2BlockByBatchNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastL2BlockByBatchNumber_Call) Return(_a0 *state.L2Block, _a1 error) *StateFullInterface_GetLastL2BlockByBatchNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastL2BlockByBatchNumber_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.L2Block, error)) *StateFullInterface_GetLastL2BlockByBatchNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastL2BlockNumber provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetLastL2BlockNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) (uint64, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) uint64); ok {
		r0 = rf(ctx, dbTx)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastL2BlockNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastL2BlockNumber(ctx interface{}, dbTx interface{}) *StateFullInterface_GetLastL2BlockNumber_Call {
	return &StateFullInterface_GetLastL2BlockNumber_Call{Call: _e.mock.On("GetLastL2BlockNumber", ctx, dbTx)}
}

func (_c *StateFullInterface_GetLastL2BlockNumber_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetLastL2BlockNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastL2BlockNumber_Call) Return(_a0 uint64, _a1 error) *StateFullInterface_GetLastL2BlockNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastL2BlockNumber_Call) RunAndReturn(run func(context.Context, pgx.Tx) (uint64, error)) *StateFullInterface_GetLastL2BlockNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastVerifiedBatch provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetLastVerifiedBatch(ctx context.Context, dbTx pgx.Tx) (*state.VerifiedBatch, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 *state.VerifiedBatch
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) (*state.VerifiedBatch, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) *state.VerifiedBatch); ok {
		r0 = rf(ctx, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.VerifiedBatch)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastVerifiedBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastVerifiedBatch(ctx interface{}, dbTx interface{}) *StateFullInterface_GetLastVerifiedBatch_Call {
	return &StateFullInterface_GetLastVerifiedBatch_Call{Call: _e.mock.On("GetLastVerifiedBatch", ctx, dbTx)}
}

func (_c *StateFullInterface_GetLastVerifiedBatch_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetLastVerifiedBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastVerifiedBatch_Call) Return(_a0 *state.VerifiedBatch, _a1 error) *StateFullInterface_GetLastVerifiedBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastVerifiedBatch_Call) RunAndReturn(run func(context.Context, pgx.Tx) (*state.VerifiedBatch, error)) *StateFullInterface_GetLastVerifiedBatch_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastVirtualBatchNum provides a mock function with given fields: ctx, dbTx
func (_m *StateFullInterface) GetLastVirtualBatchNum(ctx context.Context, dbTx pgx.Tx) (uint64, error) {
	ret := _m.Called(ctx, dbTx)

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

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) (uint64, error)); ok {
		return rf(ctx, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, pgx.Tx) uint64); ok {
		r0 = rf(ctx, dbTx)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, pgx.Tx) error); ok {
		r1 = rf(ctx, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLastVirtualBatchNum is a helper method to define mock.On call
//   - ctx context.Context
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetLastVirtualBatchNum(ctx interface{}, dbTx interface{}) *StateFullInterface_GetLastVirtualBatchNum_Call {
	return &StateFullInterface_GetLastVirtualBatchNum_Call{Call: _e.mock.On("GetLastVirtualBatchNum", ctx, dbTx)}
}

func (_c *StateFullInterface_GetLastVirtualBatchNum_Call) Run(run func(ctx context.Context, dbTx pgx.Tx)) *StateFullInterface_GetLastVirtualBatchNum_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetLastVirtualBatchNum_Call) Return(_a0 uint64, _a1 error) *StateFullInterface_GetLastVirtualBatchNum_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetLastVirtualBatchNum_Call) RunAndReturn(run func(context.Context, pgx.Tx) (uint64, error)) *StateFullInterface_GetLastVirtualBatchNum_Call {
	_c.Call.Return(run)
	return _c
}

// GetNextForcedBatches provides a mock function with given fields: ctx, nextForcedBatches, dbTx
func (_m *StateFullInterface) GetNextForcedBatches(ctx context.Context, nextForcedBatches int, dbTx pgx.Tx) ([]state.ForcedBatch, error) {
	ret := _m.Called(ctx, nextForcedBatches, dbTx)

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

	var r0 []state.ForcedBatch
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int, pgx.Tx) ([]state.ForcedBatch, error)); ok {
		return rf(ctx, nextForcedBatches, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int, pgx.Tx) []state.ForcedBatch); ok {
		r0 = rf(ctx, nextForcedBatches, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]state.ForcedBatch)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int, pgx.Tx) error); ok {
		r1 = rf(ctx, nextForcedBatches, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetNextForcedBatches is a helper method to define mock.On call
//   - ctx context.Context
//   - nextForcedBatches int
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetNextForcedBatches(ctx interface{}, nextForcedBatches interface{}, dbTx interface{}) *StateFullInterface_GetNextForcedBatches_Call {
	return &StateFullInterface_GetNextForcedBatches_Call{Call: _e.mock.On("GetNextForcedBatches", ctx, nextForcedBatches, dbTx)}
}

func (_c *StateFullInterface_GetNextForcedBatches_Call) Run(run func(ctx context.Context, nextForcedBatches int, dbTx pgx.Tx)) *StateFullInterface_GetNextForcedBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetNextForcedBatches_Call) Return(_a0 []state.ForcedBatch, _a1 error) *StateFullInterface_GetNextForcedBatches_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetNextForcedBatches_Call) RunAndReturn(run func(context.Context, int, pgx.Tx) ([]state.ForcedBatch, error)) *StateFullInterface_GetNextForcedBatches_Call {
	_c.Call.Return(run)
	return _c
}

// GetPreviousBlock provides a mock function with given fields: ctx, offset, dbTx
func (_m *StateFullInterface) GetPreviousBlock(ctx context.Context, offset uint64, dbTx pgx.Tx) (*state.Block, error) {
	ret := _m.Called(ctx, offset, dbTx)

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

	var r0 *state.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.Block, error)); ok {
		return rf(ctx, offset, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.Block); ok {
		r0 = rf(ctx, offset, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, offset, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPreviousBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - offset uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetPreviousBlock(ctx interface{}, offset interface{}, dbTx interface{}) *StateFullInterface_GetPreviousBlock_Call {
	return &StateFullInterface_GetPreviousBlock_Call{Call: _e.mock.On("GetPreviousBlock", ctx, offset, dbTx)}
}

func (_c *StateFullInterface_GetPreviousBlock_Call) Run(run func(ctx context.Context, offset uint64, dbTx pgx.Tx)) *StateFullInterface_GetPreviousBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetPreviousBlock_Call) Return(_a0 *state.Block, _a1 error) *StateFullInterface_GetPreviousBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetPreviousBlock_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.Block, error)) *StateFullInterface_GetPreviousBlock_Call {
	_c.Call.Return(run)
	return _c
}

// GetPreviousBlockToBlockNumber provides a mock function with given fields: ctx, blockNumber, dbTx
func (_m *StateFullInterface) GetPreviousBlockToBlockNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (*state.Block, error) {
	ret := _m.Called(ctx, blockNumber, dbTx)

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

	var r0 *state.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (*state.Block, error)); ok {
		return rf(ctx, blockNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) *state.Block); ok {
		r0 = rf(ctx, blockNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, blockNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPreviousBlockToBlockNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - blockNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetPreviousBlockToBlockNumber(ctx interface{}, blockNumber interface{}, dbTx interface{}) *StateFullInterface_GetPreviousBlockToBlockNumber_Call {
	return &StateFullInterface_GetPreviousBlockToBlockNumber_Call{Call: _e.mock.On("GetPreviousBlockToBlockNumber", ctx, blockNumber, dbTx)}
}

func (_c *StateFullInterface_GetPreviousBlockToBlockNumber_Call) Run(run func(ctx context.Context, blockNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetPreviousBlockToBlockNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetPreviousBlockToBlockNumber_Call) Return(_a0 *state.Block, _a1 error) *StateFullInterface_GetPreviousBlockToBlockNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetPreviousBlockToBlockNumber_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (*state.Block, error)) *StateFullInterface_GetPreviousBlockToBlockNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetReorgedTransactions provides a mock function with given fields: ctx, batchNumber, dbTx
func (_m *StateFullInterface) GetReorgedTransactions(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) ([]*types.Transaction, error) {
	ret := _m.Called(ctx, batchNumber, dbTx)

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

	var r0 []*types.Transaction
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) ([]*types.Transaction, error)); ok {
		return rf(ctx, batchNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) []*types.Transaction); ok {
		r0 = rf(ctx, batchNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Transaction)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, batchNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetReorgedTransactions is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetReorgedTransactions(ctx interface{}, batchNumber interface{}, dbTx interface{}) *StateFullInterface_GetReorgedTransactions_Call {
	return &StateFullInterface_GetReorgedTransactions_Call{Call: _e.mock.On("GetReorgedTransactions", ctx, batchNumber, dbTx)}
}

func (_c *StateFullInterface_GetReorgedTransactions_Call) Run(run func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetReorgedTransactions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetReorgedTransactions_Call) Return(_a0 []*types.Transaction, _a1 error) *StateFullInterface_GetReorgedTransactions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetReorgedTransactions_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) ([]*types.Transaction, error)) *StateFullInterface_GetReorgedTransactions_Call {
	_c.Call.Return(run)
	return _c
}

// GetStateRootByBatchNumber provides a mock function with given fields: ctx, batchNum, dbTx
func (_m *StateFullInterface) GetStateRootByBatchNumber(ctx context.Context, batchNum uint64, dbTx pgx.Tx) (common.Hash, error) {
	ret := _m.Called(ctx, batchNum, dbTx)

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

	var r0 common.Hash
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) (common.Hash, error)); ok {
		return rf(ctx, batchNum, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) common.Hash); ok {
		r0 = rf(ctx, batchNum, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, batchNum, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetStateRootByBatchNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNum uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetStateRootByBatchNumber(ctx interface{}, batchNum interface{}, dbTx interface{}) *StateFullInterface_GetStateRootByBatchNumber_Call {
	return &StateFullInterface_GetStateRootByBatchNumber_Call{Call: _e.mock.On("GetStateRootByBatchNumber", ctx, batchNum, dbTx)}
}

func (_c *StateFullInterface_GetStateRootByBatchNumber_Call) Run(run func(ctx context.Context, batchNum uint64, dbTx pgx.Tx)) *StateFullInterface_GetStateRootByBatchNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

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

func (_c *StateFullInterface_GetStateRootByBatchNumber_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) (common.Hash, error)) *StateFullInterface_GetStateRootByBatchNumber_Call {
	_c.Call.Return(run)
	return _c
}

// GetStoredFlushID provides a mock function with given fields: ctx
func (_m *StateFullInterface) GetStoredFlushID(ctx context.Context) (uint64, string, error) {
	ret := _m.Called(ctx)

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

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

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

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

	return r0, r1, r2
}

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

// GetStoredFlushID is a helper method to define mock.On call
//   - ctx context.Context
func (_e *StateFullInterface_Expecter) GetStoredFlushID(ctx interface{}) *StateFullInterface_GetStoredFlushID_Call {
	return &StateFullInterface_GetStoredFlushID_Call{Call: _e.mock.On("GetStoredFlushID", ctx)}
}

func (_c *StateFullInterface_GetStoredFlushID_Call) Run(run func(ctx context.Context)) *StateFullInterface_GetStoredFlushID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

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

func (_c *StateFullInterface_GetStoredFlushID_Call) RunAndReturn(run func(context.Context) (uint64, string, error)) *StateFullInterface_GetStoredFlushID_Call {
	_c.Call.Return(run)
	return _c
}

// GetUncheckedBlocks provides a mock function with given fields: ctx, fromBlockNumber, toBlockNumber, dbTx
func (_m *StateFullInterface) GetUncheckedBlocks(ctx context.Context, fromBlockNumber uint64, toBlockNumber uint64, dbTx pgx.Tx) ([]*state.Block, error) {
	ret := _m.Called(ctx, fromBlockNumber, toBlockNumber, dbTx)

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

	var r0 []*state.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, uint64, pgx.Tx) ([]*state.Block, error)); ok {
		return rf(ctx, fromBlockNumber, toBlockNumber, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, uint64, pgx.Tx) []*state.Block); ok {
		r0 = rf(ctx, fromBlockNumber, toBlockNumber, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*state.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, uint64, pgx.Tx) error); ok {
		r1 = rf(ctx, fromBlockNumber, toBlockNumber, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUncheckedBlocks is a helper method to define mock.On call
//   - ctx context.Context
//   - fromBlockNumber uint64
//   - toBlockNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) GetUncheckedBlocks(ctx interface{}, fromBlockNumber interface{}, toBlockNumber interface{}, dbTx interface{}) *StateFullInterface_GetUncheckedBlocks_Call {
	return &StateFullInterface_GetUncheckedBlocks_Call{Call: _e.mock.On("GetUncheckedBlocks", ctx, fromBlockNumber, toBlockNumber, dbTx)}
}

func (_c *StateFullInterface_GetUncheckedBlocks_Call) Run(run func(ctx context.Context, fromBlockNumber uint64, toBlockNumber uint64, dbTx pgx.Tx)) *StateFullInterface_GetUncheckedBlocks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(uint64), args[3].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_GetUncheckedBlocks_Call) Return(_a0 []*state.Block, _a1 error) *StateFullInterface_GetUncheckedBlocks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_GetUncheckedBlocks_Call) RunAndReturn(run func(context.Context, uint64, uint64, pgx.Tx) ([]*state.Block, error)) *StateFullInterface_GetUncheckedBlocks_Call {
	_c.Call.Return(run)
	return _c
}

// OpenBatch provides a mock function with given fields: ctx, processingContext, dbTx
func (_m *StateFullInterface) OpenBatch(ctx context.Context, processingContext state.ProcessingContext, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, processingContext, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingContext, pgx.Tx) error); ok {
		r0 = rf(ctx, processingContext, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// OpenBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - processingContext state.ProcessingContext
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) OpenBatch(ctx interface{}, processingContext interface{}, dbTx interface{}) *StateFullInterface_OpenBatch_Call {
	return &StateFullInterface_OpenBatch_Call{Call: _e.mock.On("OpenBatch", ctx, processingContext, dbTx)}
}

func (_c *StateFullInterface_OpenBatch_Call) Run(run func(ctx context.Context, processingContext state.ProcessingContext, dbTx pgx.Tx)) *StateFullInterface_OpenBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessingContext), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_OpenBatch_Call) Return(_a0 error) *StateFullInterface_OpenBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_OpenBatch_Call) RunAndReturn(run func(context.Context, state.ProcessingContext, pgx.Tx) error) *StateFullInterface_OpenBatch_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessAndStoreClosedBatch provides a mock function with given fields: ctx, processingCtx, encodedTxs, dbTx, caller
func (_m *StateFullInterface) ProcessAndStoreClosedBatch(ctx context.Context, processingCtx state.ProcessingContext, encodedTxs []byte, dbTx pgx.Tx, caller metrics.CallerLabel) (common.Hash, uint64, string, error) {
	ret := _m.Called(ctx, processingCtx, encodedTxs, dbTx, caller)

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

	var r0 common.Hash
	var r1 uint64
	var r2 string
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingContext, []byte, pgx.Tx, metrics.CallerLabel) (common.Hash, uint64, string, error)); ok {
		return rf(ctx, processingCtx, encodedTxs, dbTx, caller)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingContext, []byte, pgx.Tx, metrics.CallerLabel) common.Hash); ok {
		r0 = rf(ctx, processingCtx, encodedTxs, dbTx, caller)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.ProcessingContext, []byte, pgx.Tx, metrics.CallerLabel) uint64); ok {
		r1 = rf(ctx, processingCtx, encodedTxs, dbTx, caller)
	} else {
		r1 = ret.Get(1).(uint64)
	}

	if rf, ok := ret.Get(2).(func(context.Context, state.ProcessingContext, []byte, pgx.Tx, metrics.CallerLabel) string); ok {
		r2 = rf(ctx, processingCtx, encodedTxs, dbTx, caller)
	} else {
		r2 = ret.Get(2).(string)
	}

	if rf, ok := ret.Get(3).(func(context.Context, state.ProcessingContext, []byte, pgx.Tx, metrics.CallerLabel) error); ok {
		r3 = rf(ctx, processingCtx, encodedTxs, dbTx, caller)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

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

// ProcessAndStoreClosedBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - processingCtx state.ProcessingContext
//   - encodedTxs []byte
//   - dbTx pgx.Tx
//   - caller metrics.CallerLabel
func (_e *StateFullInterface_Expecter) ProcessAndStoreClosedBatch(ctx interface{}, processingCtx interface{}, encodedTxs interface{}, dbTx interface{}, caller interface{}) *StateFullInterface_ProcessAndStoreClosedBatch_Call {
	return &StateFullInterface_ProcessAndStoreClosedBatch_Call{Call: _e.mock.On("ProcessAndStoreClosedBatch", ctx, processingCtx, encodedTxs, dbTx, caller)}
}

func (_c *StateFullInterface_ProcessAndStoreClosedBatch_Call) Run(run func(ctx context.Context, processingCtx state.ProcessingContext, encodedTxs []byte, dbTx pgx.Tx, caller metrics.CallerLabel)) *StateFullInterface_ProcessAndStoreClosedBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessingContext), args[2].([]byte), args[3].(pgx.Tx), args[4].(metrics.CallerLabel))
	})
	return _c
}

func (_c *StateFullInterface_ProcessAndStoreClosedBatch_Call) Return(_a0 common.Hash, _a1 uint64, _a2 string, _a3 error) *StateFullInterface_ProcessAndStoreClosedBatch_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *StateFullInterface_ProcessAndStoreClosedBatch_Call) RunAndReturn(run func(context.Context, state.ProcessingContext, []byte, pgx.Tx, metrics.CallerLabel) (common.Hash, uint64, string, error)) *StateFullInterface_ProcessAndStoreClosedBatch_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessAndStoreClosedBatchV2 provides a mock function with given fields: ctx, processingCtx, dbTx, caller
func (_m *StateFullInterface) ProcessAndStoreClosedBatchV2(ctx context.Context, processingCtx state.ProcessingContextV2, dbTx pgx.Tx, caller metrics.CallerLabel) (common.Hash, uint64, string, error) {
	ret := _m.Called(ctx, processingCtx, dbTx, caller)

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

	var r0 common.Hash
	var r1 uint64
	var r2 string
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingContextV2, pgx.Tx, metrics.CallerLabel) (common.Hash, uint64, string, error)); ok {
		return rf(ctx, processingCtx, dbTx, caller)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingContextV2, pgx.Tx, metrics.CallerLabel) common.Hash); ok {
		r0 = rf(ctx, processingCtx, dbTx, caller)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.ProcessingContextV2, pgx.Tx, metrics.CallerLabel) uint64); ok {
		r1 = rf(ctx, processingCtx, dbTx, caller)
	} else {
		r1 = ret.Get(1).(uint64)
	}

	if rf, ok := ret.Get(2).(func(context.Context, state.ProcessingContextV2, pgx.Tx, metrics.CallerLabel) string); ok {
		r2 = rf(ctx, processingCtx, dbTx, caller)
	} else {
		r2 = ret.Get(2).(string)
	}

	if rf, ok := ret.Get(3).(func(context.Context, state.ProcessingContextV2, pgx.Tx, metrics.CallerLabel) error); ok {
		r3 = rf(ctx, processingCtx, dbTx, caller)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

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

// ProcessAndStoreClosedBatchV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - processingCtx state.ProcessingContextV2
//   - dbTx pgx.Tx
//   - caller metrics.CallerLabel
func (_e *StateFullInterface_Expecter) ProcessAndStoreClosedBatchV2(ctx interface{}, processingCtx interface{}, dbTx interface{}, caller interface{}) *StateFullInterface_ProcessAndStoreClosedBatchV2_Call {
	return &StateFullInterface_ProcessAndStoreClosedBatchV2_Call{Call: _e.mock.On("ProcessAndStoreClosedBatchV2", ctx, processingCtx, dbTx, caller)}
}

func (_c *StateFullInterface_ProcessAndStoreClosedBatchV2_Call) Run(run func(ctx context.Context, processingCtx state.ProcessingContextV2, dbTx pgx.Tx, caller metrics.CallerLabel)) *StateFullInterface_ProcessAndStoreClosedBatchV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessingContextV2), args[2].(pgx.Tx), args[3].(metrics.CallerLabel))
	})
	return _c
}

func (_c *StateFullInterface_ProcessAndStoreClosedBatchV2_Call) Return(_a0 common.Hash, _a1 uint64, _a2 string, _a3 error) *StateFullInterface_ProcessAndStoreClosedBatchV2_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *StateFullInterface_ProcessAndStoreClosedBatchV2_Call) RunAndReturn(run func(context.Context, state.ProcessingContextV2, pgx.Tx, metrics.CallerLabel) (common.Hash, uint64, string, error)) *StateFullInterface_ProcessAndStoreClosedBatchV2_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessBatch provides a mock function with given fields: ctx, request, updateMerkleTree
func (_m *StateFullInterface) ProcessBatch(ctx context.Context, request state.ProcessRequest, updateMerkleTree bool) (*state.ProcessBatchResponse, error) {
	ret := _m.Called(ctx, request, updateMerkleTree)

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

	var r0 *state.ProcessBatchResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessRequest, bool) (*state.ProcessBatchResponse, error)); ok {
		return rf(ctx, request, updateMerkleTree)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessRequest, bool) *state.ProcessBatchResponse); ok {
		r0 = rf(ctx, request, updateMerkleTree)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ProcessBatchResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.ProcessRequest, bool) error); ok {
		r1 = rf(ctx, request, updateMerkleTree)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ProcessBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - request state.ProcessRequest
//   - updateMerkleTree bool
func (_e *StateFullInterface_Expecter) ProcessBatch(ctx interface{}, request interface{}, updateMerkleTree interface{}) *StateFullInterface_ProcessBatch_Call {
	return &StateFullInterface_ProcessBatch_Call{Call: _e.mock.On("ProcessBatch", ctx, request, updateMerkleTree)}
}

func (_c *StateFullInterface_ProcessBatch_Call) Run(run func(ctx context.Context, request state.ProcessRequest, updateMerkleTree bool)) *StateFullInterface_ProcessBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessRequest), args[2].(bool))
	})
	return _c
}

func (_c *StateFullInterface_ProcessBatch_Call) Return(_a0 *state.ProcessBatchResponse, _a1 error) *StateFullInterface_ProcessBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_ProcessBatch_Call) RunAndReturn(run func(context.Context, state.ProcessRequest, bool) (*state.ProcessBatchResponse, error)) *StateFullInterface_ProcessBatch_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessBatchV2 provides a mock function with given fields: ctx, request, updateMerkleTree
func (_m *StateFullInterface) ProcessBatchV2(ctx context.Context, request state.ProcessRequest, updateMerkleTree bool) (*state.ProcessBatchResponse, string, error) {
	ret := _m.Called(ctx, request, updateMerkleTree)

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

	var r0 *state.ProcessBatchResponse
	var r1 string
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessRequest, bool) (*state.ProcessBatchResponse, string, error)); ok {
		return rf(ctx, request, updateMerkleTree)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessRequest, bool) *state.ProcessBatchResponse); ok {
		r0 = rf(ctx, request, updateMerkleTree)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ProcessBatchResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.ProcessRequest, bool) string); ok {
		r1 = rf(ctx, request, updateMerkleTree)
	} else {
		r1 = ret.Get(1).(string)
	}

	if rf, ok := ret.Get(2).(func(context.Context, state.ProcessRequest, bool) error); ok {
		r2 = rf(ctx, request, updateMerkleTree)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ProcessBatchV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - request state.ProcessRequest
//   - updateMerkleTree bool
func (_e *StateFullInterface_Expecter) ProcessBatchV2(ctx interface{}, request interface{}, updateMerkleTree interface{}) *StateFullInterface_ProcessBatchV2_Call {
	return &StateFullInterface_ProcessBatchV2_Call{Call: _e.mock.On("ProcessBatchV2", ctx, request, updateMerkleTree)}
}

func (_c *StateFullInterface_ProcessBatchV2_Call) Run(run func(ctx context.Context, request state.ProcessRequest, updateMerkleTree bool)) *StateFullInterface_ProcessBatchV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessRequest), args[2].(bool))
	})
	return _c
}

func (_c *StateFullInterface_ProcessBatchV2_Call) Return(_a0 *state.ProcessBatchResponse, _a1 string, _a2 error) *StateFullInterface_ProcessBatchV2_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *StateFullInterface_ProcessBatchV2_Call) RunAndReturn(run func(context.Context, state.ProcessRequest, bool) (*state.ProcessBatchResponse, string, error)) *StateFullInterface_ProcessBatchV2_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessBlobInner provides a mock function with given fields: ctx, request, data
func (_m *StateFullInterface) ProcessBlobInner(ctx context.Context, request state.ProcessBlobInnerProcessRequest, data []byte) (*state.ProcessBlobInnerResponse, error) {
	ret := _m.Called(ctx, request, data)

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

	var r0 *state.ProcessBlobInnerResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessBlobInnerProcessRequest, []byte) (*state.ProcessBlobInnerResponse, error)); ok {
		return rf(ctx, request, data)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessBlobInnerProcessRequest, []byte) *state.ProcessBlobInnerResponse); ok {
		r0 = rf(ctx, request, data)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ProcessBlobInnerResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.ProcessBlobInnerProcessRequest, []byte) error); ok {
		r1 = rf(ctx, request, data)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ProcessBlobInner is a helper method to define mock.On call
//   - ctx context.Context
//   - request state.ProcessBlobInnerProcessRequest
//   - data []byte
func (_e *StateFullInterface_Expecter) ProcessBlobInner(ctx interface{}, request interface{}, data interface{}) *StateFullInterface_ProcessBlobInner_Call {
	return &StateFullInterface_ProcessBlobInner_Call{Call: _e.mock.On("ProcessBlobInner", ctx, request, data)}
}

func (_c *StateFullInterface_ProcessBlobInner_Call) Run(run func(ctx context.Context, request state.ProcessBlobInnerProcessRequest, data []byte)) *StateFullInterface_ProcessBlobInner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessBlobInnerProcessRequest), args[2].([]byte))
	})
	return _c
}

func (_c *StateFullInterface_ProcessBlobInner_Call) Return(_a0 *state.ProcessBlobInnerResponse, _a1 error) *StateFullInterface_ProcessBlobInner_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_ProcessBlobInner_Call) RunAndReturn(run func(context.Context, state.ProcessBlobInnerProcessRequest, []byte) (*state.ProcessBlobInnerResponse, error)) *StateFullInterface_ProcessBlobInner_Call {
	_c.Call.Return(run)
	return _c
}

// Reset provides a mock function with given fields: ctx, blockNumber, dbTx
func (_m *StateFullInterface) Reset(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, blockNumber, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) error); ok {
		r0 = rf(ctx, blockNumber, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Reset is a helper method to define mock.On call
//   - ctx context.Context
//   - blockNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) Reset(ctx interface{}, blockNumber interface{}, dbTx interface{}) *StateFullInterface_Reset_Call {
	return &StateFullInterface_Reset_Call{Call: _e.mock.On("Reset", ctx, blockNumber, dbTx)}
}

func (_c *StateFullInterface_Reset_Call) Run(run func(ctx context.Context, blockNumber uint64, dbTx pgx.Tx)) *StateFullInterface_Reset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_Reset_Call) Return(_a0 error) *StateFullInterface_Reset_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_Reset_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) error) *StateFullInterface_Reset_Call {
	_c.Call.Return(run)
	return _c
}

// ResetForkID provides a mock function with given fields: ctx, batchNumber, dbTx
func (_m *StateFullInterface) ResetForkID(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, batchNumber, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) error); ok {
		r0 = rf(ctx, batchNumber, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ResetForkID is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) ResetForkID(ctx interface{}, batchNumber interface{}, dbTx interface{}) *StateFullInterface_ResetForkID_Call {
	return &StateFullInterface_ResetForkID_Call{Call: _e.mock.On("ResetForkID", ctx, batchNumber, dbTx)}
}

func (_c *StateFullInterface_ResetForkID_Call) Run(run func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx)) *StateFullInterface_ResetForkID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_ResetForkID_Call) Return(_a0 error) *StateFullInterface_ResetForkID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_ResetForkID_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) error) *StateFullInterface_ResetForkID_Call {
	_c.Call.Return(run)
	return _c
}

// ResetTrustedState provides a mock function with given fields: ctx, batchNumber, dbTx
func (_m *StateFullInterface) ResetTrustedState(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, batchNumber, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) error); ok {
		r0 = rf(ctx, batchNumber, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ResetTrustedState is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) ResetTrustedState(ctx interface{}, batchNumber interface{}, dbTx interface{}) *StateFullInterface_ResetTrustedState_Call {
	return &StateFullInterface_ResetTrustedState_Call{Call: _e.mock.On("ResetTrustedState", ctx, batchNumber, dbTx)}
}

func (_c *StateFullInterface_ResetTrustedState_Call) Run(run func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx)) *StateFullInterface_ResetTrustedState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_ResetTrustedState_Call) Return(_a0 error) *StateFullInterface_ResetTrustedState_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_ResetTrustedState_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) error) *StateFullInterface_ResetTrustedState_Call {
	_c.Call.Return(run)
	return _c
}

// SetGenesis provides a mock function with given fields: ctx, block, genesis, m, dbTx
func (_m *StateFullInterface) SetGenesis(ctx context.Context, block state.Block, genesis state.Genesis, m metrics.CallerLabel, dbTx pgx.Tx) (common.Hash, error) {
	ret := _m.Called(ctx, block, genesis, m, dbTx)

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

	var r0 common.Hash
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, state.Block, state.Genesis, metrics.CallerLabel, pgx.Tx) (common.Hash, error)); ok {
		return rf(ctx, block, genesis, m, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, state.Block, state.Genesis, metrics.CallerLabel, pgx.Tx) common.Hash); ok {
		r0 = rf(ctx, block, genesis, m, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, state.Block, state.Genesis, metrics.CallerLabel, pgx.Tx) error); ok {
		r1 = rf(ctx, block, genesis, m, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetGenesis is a helper method to define mock.On call
//   - ctx context.Context
//   - block state.Block
//   - genesis state.Genesis
//   - m metrics.CallerLabel
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) SetGenesis(ctx interface{}, block interface{}, genesis interface{}, m interface{}, dbTx interface{}) *StateFullInterface_SetGenesis_Call {
	return &StateFullInterface_SetGenesis_Call{Call: _e.mock.On("SetGenesis", ctx, block, genesis, m, dbTx)}
}

func (_c *StateFullInterface_SetGenesis_Call) Run(run func(ctx context.Context, block state.Block, genesis state.Genesis, m metrics.CallerLabel, dbTx pgx.Tx)) *StateFullInterface_SetGenesis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.Block), args[2].(state.Genesis), args[3].(metrics.CallerLabel), args[4].(pgx.Tx))
	})
	return _c
}

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

func (_c *StateFullInterface_SetGenesis_Call) RunAndReturn(run func(context.Context, state.Block, state.Genesis, metrics.CallerLabel, pgx.Tx) (common.Hash, error)) *StateFullInterface_SetGenesis_Call {
	_c.Call.Return(run)
	return _c
}

// SetInitSyncBatch provides a mock function with given fields: ctx, batchNumber, dbTx
func (_m *StateFullInterface) SetInitSyncBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, batchNumber, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, pgx.Tx) error); ok {
		r0 = rf(ctx, batchNumber, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetInitSyncBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) SetInitSyncBatch(ctx interface{}, batchNumber interface{}, dbTx interface{}) *StateFullInterface_SetInitSyncBatch_Call {
	return &StateFullInterface_SetInitSyncBatch_Call{Call: _e.mock.On("SetInitSyncBatch", ctx, batchNumber, dbTx)}
}

func (_c *StateFullInterface_SetInitSyncBatch_Call) Run(run func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx)) *StateFullInterface_SetInitSyncBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_SetInitSyncBatch_Call) Return(_a0 error) *StateFullInterface_SetInitSyncBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_SetInitSyncBatch_Call) RunAndReturn(run func(context.Context, uint64, pgx.Tx) error) *StateFullInterface_SetInitSyncBatch_Call {
	_c.Call.Return(run)
	return _c
}

// SetLastBatchInfoSeenOnEthereum provides a mock function with given fields: ctx, lastBatchNumberSeen, lastBatchNumberVerified, dbTx
func (_m *StateFullInterface) SetLastBatchInfoSeenOnEthereum(ctx context.Context, lastBatchNumberSeen uint64, lastBatchNumberVerified uint64, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, lastBatchNumberSeen, lastBatchNumberVerified, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, uint64, pgx.Tx) error); ok {
		r0 = rf(ctx, lastBatchNumberSeen, lastBatchNumberVerified, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetLastBatchInfoSeenOnEthereum is a helper method to define mock.On call
//   - ctx context.Context
//   - lastBatchNumberSeen uint64
//   - lastBatchNumberVerified uint64
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) SetLastBatchInfoSeenOnEthereum(ctx interface{}, lastBatchNumberSeen interface{}, lastBatchNumberVerified interface{}, dbTx interface{}) *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call {
	return &StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call{Call: _e.mock.On("SetLastBatchInfoSeenOnEthereum", ctx, lastBatchNumberSeen, lastBatchNumberVerified, dbTx)}
}

func (_c *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call) Run(run func(ctx context.Context, lastBatchNumberSeen uint64, lastBatchNumberVerified uint64, dbTx pgx.Tx)) *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(uint64), args[3].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call) Return(_a0 error) *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call) RunAndReturn(run func(context.Context, uint64, uint64, pgx.Tx) error) *StateFullInterface_SetLastBatchInfoSeenOnEthereum_Call {
	_c.Call.Return(run)
	return _c
}

// StoreL2Block provides a mock function with given fields: ctx, batchNumber, l2Block, txsEGPLog, dbTx
func (_m *StateFullInterface) StoreL2Block(ctx context.Context, batchNumber uint64, l2Block *state.ProcessBlockResponse, txsEGPLog []*state.EffectiveGasPriceLog, dbTx pgx.Tx) (common.Hash, error) {
	ret := _m.Called(ctx, batchNumber, l2Block, txsEGPLog, dbTx)

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

	var r0 common.Hash
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, *state.ProcessBlockResponse, []*state.EffectiveGasPriceLog, pgx.Tx) (common.Hash, error)); ok {
		return rf(ctx, batchNumber, l2Block, txsEGPLog, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, *state.ProcessBlockResponse, []*state.EffectiveGasPriceLog, pgx.Tx) common.Hash); ok {
		r0 = rf(ctx, batchNumber, l2Block, txsEGPLog, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, *state.ProcessBlockResponse, []*state.EffectiveGasPriceLog, pgx.Tx) error); ok {
		r1 = rf(ctx, batchNumber, l2Block, txsEGPLog, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StoreL2Block is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - l2Block *state.ProcessBlockResponse
//   - txsEGPLog []*state.EffectiveGasPriceLog
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) StoreL2Block(ctx interface{}, batchNumber interface{}, l2Block interface{}, txsEGPLog interface{}, dbTx interface{}) *StateFullInterface_StoreL2Block_Call {
	return &StateFullInterface_StoreL2Block_Call{Call: _e.mock.On("StoreL2Block", ctx, batchNumber, l2Block, txsEGPLog, dbTx)}
}

func (_c *StateFullInterface_StoreL2Block_Call) Run(run func(ctx context.Context, batchNumber uint64, l2Block *state.ProcessBlockResponse, txsEGPLog []*state.EffectiveGasPriceLog, dbTx pgx.Tx)) *StateFullInterface_StoreL2Block_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(*state.ProcessBlockResponse), args[3].([]*state.EffectiveGasPriceLog), args[4].(pgx.Tx))
	})
	return _c
}

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

func (_c *StateFullInterface_StoreL2Block_Call) RunAndReturn(run func(context.Context, uint64, *state.ProcessBlockResponse, []*state.EffectiveGasPriceLog, pgx.Tx) (common.Hash, error)) *StateFullInterface_StoreL2Block_Call {
	_c.Call.Return(run)
	return _c
}

// StoreTransaction provides a mock function with given fields: ctx, batchNumber, processedTx, coinbase, timestamp, egpLog, globalExitRoot, blockInfoRoot, dbTx
func (_m *StateFullInterface) StoreTransaction(ctx context.Context, batchNumber uint64, processedTx *state.ProcessTransactionResponse, coinbase common.Address, timestamp uint64, egpLog *state.EffectiveGasPriceLog, globalExitRoot common.Hash, blockInfoRoot common.Hash, dbTx pgx.Tx) (*state.L2Header, error) {
	ret := _m.Called(ctx, batchNumber, processedTx, coinbase, timestamp, egpLog, globalExitRoot, blockInfoRoot, dbTx)

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

	var r0 *state.L2Header
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, *state.ProcessTransactionResponse, common.Address, uint64, *state.EffectiveGasPriceLog, common.Hash, common.Hash, pgx.Tx) (*state.L2Header, error)); ok {
		return rf(ctx, batchNumber, processedTx, coinbase, timestamp, egpLog, globalExitRoot, blockInfoRoot, dbTx)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64, *state.ProcessTransactionResponse, common.Address, uint64, *state.EffectiveGasPriceLog, common.Hash, common.Hash, pgx.Tx) *state.L2Header); ok {
		r0 = rf(ctx, batchNumber, processedTx, coinbase, timestamp, egpLog, globalExitRoot, blockInfoRoot, dbTx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.L2Header)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uint64, *state.ProcessTransactionResponse, common.Address, uint64, *state.EffectiveGasPriceLog, common.Hash, common.Hash, pgx.Tx) error); ok {
		r1 = rf(ctx, batchNumber, processedTx, coinbase, timestamp, egpLog, globalExitRoot, blockInfoRoot, dbTx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StoreTransaction is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - processedTx *state.ProcessTransactionResponse
//   - coinbase common.Address
//   - timestamp uint64
//   - egpLog *state.EffectiveGasPriceLog
//   - globalExitRoot common.Hash
//   - blockInfoRoot common.Hash
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) StoreTransaction(ctx interface{}, batchNumber interface{}, processedTx interface{}, coinbase interface{}, timestamp interface{}, egpLog interface{}, globalExitRoot interface{}, blockInfoRoot interface{}, dbTx interface{}) *StateFullInterface_StoreTransaction_Call {
	return &StateFullInterface_StoreTransaction_Call{Call: _e.mock.On("StoreTransaction", ctx, batchNumber, processedTx, coinbase, timestamp, egpLog, globalExitRoot, blockInfoRoot, dbTx)}
}

func (_c *StateFullInterface_StoreTransaction_Call) Run(run func(ctx context.Context, batchNumber uint64, processedTx *state.ProcessTransactionResponse, coinbase common.Address, timestamp uint64, egpLog *state.EffectiveGasPriceLog, globalExitRoot common.Hash, blockInfoRoot common.Hash, dbTx pgx.Tx)) *StateFullInterface_StoreTransaction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(*state.ProcessTransactionResponse), args[3].(common.Address), args[4].(uint64), args[5].(*state.EffectiveGasPriceLog), args[6].(common.Hash), args[7].(common.Hash), args[8].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_StoreTransaction_Call) Return(_a0 *state.L2Header, _a1 error) *StateFullInterface_StoreTransaction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *StateFullInterface_StoreTransaction_Call) RunAndReturn(run func(context.Context, uint64, *state.ProcessTransactionResponse, common.Address, uint64, *state.EffectiveGasPriceLog, common.Hash, common.Hash, pgx.Tx) (*state.L2Header, error)) *StateFullInterface_StoreTransaction_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBatchL2Data provides a mock function with given fields: ctx, batchNumber, batchL2Data, dbTx
func (_m *StateFullInterface) UpdateBatchL2Data(ctx context.Context, batchNumber uint64, batchL2Data []byte, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, batchNumber, batchL2Data, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, []byte, pgx.Tx) error); ok {
		r0 = rf(ctx, batchNumber, batchL2Data, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateBatchL2Data is a helper method to define mock.On call
//   - ctx context.Context
//   - batchNumber uint64
//   - batchL2Data []byte
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) UpdateBatchL2Data(ctx interface{}, batchNumber interface{}, batchL2Data interface{}, dbTx interface{}) *StateFullInterface_UpdateBatchL2Data_Call {
	return &StateFullInterface_UpdateBatchL2Data_Call{Call: _e.mock.On("UpdateBatchL2Data", ctx, batchNumber, batchL2Data, dbTx)}
}

func (_c *StateFullInterface_UpdateBatchL2Data_Call) Run(run func(ctx context.Context, batchNumber uint64, batchL2Data []byte, dbTx pgx.Tx)) *StateFullInterface_UpdateBatchL2Data_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].([]byte), args[3].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_UpdateBatchL2Data_Call) Return(_a0 error) *StateFullInterface_UpdateBatchL2Data_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_UpdateBatchL2Data_Call) RunAndReturn(run func(context.Context, uint64, []byte, pgx.Tx) error) *StateFullInterface_UpdateBatchL2Data_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateCheckedBlockByNumber provides a mock function with given fields: ctx, blockNumber, newCheckedStatus, dbTx
func (_m *StateFullInterface) UpdateCheckedBlockByNumber(ctx context.Context, blockNumber uint64, newCheckedStatus bool, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, blockNumber, newCheckedStatus, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, bool, pgx.Tx) error); ok {
		r0 = rf(ctx, blockNumber, newCheckedStatus, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateCheckedBlockByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - blockNumber uint64
//   - newCheckedStatus bool
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) UpdateCheckedBlockByNumber(ctx interface{}, blockNumber interface{}, newCheckedStatus interface{}, dbTx interface{}) *StateFullInterface_UpdateCheckedBlockByNumber_Call {
	return &StateFullInterface_UpdateCheckedBlockByNumber_Call{Call: _e.mock.On("UpdateCheckedBlockByNumber", ctx, blockNumber, newCheckedStatus, dbTx)}
}

func (_c *StateFullInterface_UpdateCheckedBlockByNumber_Call) Run(run func(ctx context.Context, blockNumber uint64, newCheckedStatus bool, dbTx pgx.Tx)) *StateFullInterface_UpdateCheckedBlockByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(bool), args[3].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_UpdateCheckedBlockByNumber_Call) Return(_a0 error) *StateFullInterface_UpdateCheckedBlockByNumber_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_UpdateCheckedBlockByNumber_Call) RunAndReturn(run func(context.Context, uint64, bool, pgx.Tx) error) *StateFullInterface_UpdateCheckedBlockByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateForkIDBlockNumber provides a mock function with given fields: ctx, forkdID, newBlockNumber, updateMemCache, dbTx
func (_m *StateFullInterface) UpdateForkIDBlockNumber(ctx context.Context, forkdID uint64, newBlockNumber uint64, updateMemCache bool, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, forkdID, newBlockNumber, updateMemCache, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64, uint64, bool, pgx.Tx) error); ok {
		r0 = rf(ctx, forkdID, newBlockNumber, updateMemCache, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateForkIDBlockNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - forkdID uint64
//   - newBlockNumber uint64
//   - updateMemCache bool
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) UpdateForkIDBlockNumber(ctx interface{}, forkdID interface{}, newBlockNumber interface{}, updateMemCache interface{}, dbTx interface{}) *StateFullInterface_UpdateForkIDBlockNumber_Call {
	return &StateFullInterface_UpdateForkIDBlockNumber_Call{Call: _e.mock.On("UpdateForkIDBlockNumber", ctx, forkdID, newBlockNumber, updateMemCache, dbTx)}
}

func (_c *StateFullInterface_UpdateForkIDBlockNumber_Call) Run(run func(ctx context.Context, forkdID uint64, newBlockNumber uint64, updateMemCache bool, dbTx pgx.Tx)) *StateFullInterface_UpdateForkIDBlockNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64), args[2].(uint64), args[3].(bool), args[4].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_UpdateForkIDBlockNumber_Call) Return(_a0 error) *StateFullInterface_UpdateForkIDBlockNumber_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_UpdateForkIDBlockNumber_Call) RunAndReturn(run func(context.Context, uint64, uint64, bool, pgx.Tx) error) *StateFullInterface_UpdateForkIDBlockNumber_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWIPBatch provides a mock function with given fields: ctx, receipt, dbTx
func (_m *StateFullInterface) UpdateWIPBatch(ctx context.Context, receipt state.ProcessingReceipt, dbTx pgx.Tx) error {
	ret := _m.Called(ctx, receipt, dbTx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, state.ProcessingReceipt, pgx.Tx) error); ok {
		r0 = rf(ctx, receipt, dbTx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateWIPBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - receipt state.ProcessingReceipt
//   - dbTx pgx.Tx
func (_e *StateFullInterface_Expecter) UpdateWIPBatch(ctx interface{}, receipt interface{}, dbTx interface{}) *StateFullInterface_UpdateWIPBatch_Call {
	return &StateFullInterface_UpdateWIPBatch_Call{Call: _e.mock.On("UpdateWIPBatch", ctx, receipt, dbTx)}
}

func (_c *StateFullInterface_UpdateWIPBatch_Call) Run(run func(ctx context.Context, receipt state.ProcessingReceipt, dbTx pgx.Tx)) *StateFullInterface_UpdateWIPBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(state.ProcessingReceipt), args[2].(pgx.Tx))
	})
	return _c
}

func (_c *StateFullInterface_UpdateWIPBatch_Call) Return(_a0 error) *StateFullInterface_UpdateWIPBatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *StateFullInterface_UpdateWIPBatch_Call) RunAndReturn(run func(context.Context, state.ProcessingReceipt, pgx.Tx) error) *StateFullInterface_UpdateWIPBatch_Call {
	_c.Call.Return(run)
	return _c
}

// NewStateFullInterface creates a new instance of StateFullInterface. 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 NewStateFullInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *StateFullInterface {
	mock := &StateFullInterface{}
	mock.Mock.Test(t)

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

	return mock
}
