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

package mocks

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

	chains "github.com/smartcontractkit/chainlink-framework/chains"

	fees "github.com/smartcontractkit/chainlink-framework/chains/fees"

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

	null "gopkg.in/guregu/null.v4"

	time "time"

	types "github.com/smartcontractkit/chainlink-framework/chains/txmgr/types"

	uuid "github.com/google/uuid"
)

// TxStore is an autogenerated mock type for the TxStore type
type TxStore[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	mock.Mock
}

type TxStore_Expecter[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	mock *mock.Mock
}

func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) EXPECT() *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{mock: &_m.Mock}
}

// Abandon provides a mock function with given fields: ctx, id, addr
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Abandon(ctx context.Context, id CID, addr ADDR) error {
	ret := _m.Called(ctx, id, addr)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, CID, ADDR) error); ok {
		r0 = rf(ctx, id, addr)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_Abandon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Abandon'
type TxStore_Abandon_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// Abandon is a helper method to define mock.On call
//   - ctx context.Context
//   - id CID
//   - addr ADDR
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Abandon(ctx interface{}, id interface{}, addr interface{}) *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("Abandon", ctx, id, addr)}
}

func (_c *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, id CID, addr ADDR)) *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CID), args[2].(ADDR))
	})
	return _c
}

func (_c *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, CID, ADDR) error) *TxStore_Abandon_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// CheckTxQueueCapacity provides a mock function with given fields: ctx, fromAddress, maxQueuedTransactions, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CheckTxQueueCapacity(ctx context.Context, fromAddress ADDR, maxQueuedTransactions uint64, chainID CID) error {
	ret := _m.Called(ctx, fromAddress, maxQueuedTransactions, chainID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, uint64, CID) error); ok {
		r0 = rf(ctx, fromAddress, maxQueuedTransactions, chainID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_CheckTxQueueCapacity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckTxQueueCapacity'
type TxStore_CheckTxQueueCapacity_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// CheckTxQueueCapacity is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - maxQueuedTransactions uint64
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CheckTxQueueCapacity(ctx interface{}, fromAddress interface{}, maxQueuedTransactions interface{}, chainID interface{}) *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("CheckTxQueueCapacity", ctx, fromAddress, maxQueuedTransactions, chainID)}
}

func (_c *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, maxQueuedTransactions uint64, chainID CID)) *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(uint64), args[3].(CID))
	})
	return _c
}

func (_c *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(err error) *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(err)
	return _c
}

func (_c *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, uint64, CID) error) *TxStore_CheckTxQueueCapacity_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function with no fields
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Close() {
	_m.Called()
}

// TxStore_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type TxStore_Close_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Close() *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("Close")}
}

func (_c *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func()) *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return() *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return()
	return _c
}

func (_c *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func()) *TxStore_Close_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Run(run)
	return _c
}

// CountTransactionsByState provides a mock function with given fields: ctx, state, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CountTransactionsByState(ctx context.Context, state types.TxState, chainID CID) (uint32, error) {
	ret := _m.Called(ctx, state, chainID)

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

	var r0 uint32
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.TxState, CID) (uint32, error)); ok {
		return rf(ctx, state, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.TxState, CID) uint32); ok {
		r0 = rf(ctx, state, chainID)
	} else {
		r0 = ret.Get(0).(uint32)
	}

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

	return r0, r1
}

// TxStore_CountTransactionsByState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountTransactionsByState'
type TxStore_CountTransactionsByState_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// CountTransactionsByState is a helper method to define mock.On call
//   - ctx context.Context
//   - state types.TxState
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CountTransactionsByState(ctx interface{}, state interface{}, chainID interface{}) *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("CountTransactionsByState", ctx, state, chainID)}
}

func (_c *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, state types.TxState, chainID CID)) *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.TxState), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(count uint32, err error) *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(count, err)
	return _c
}

func (_c *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, types.TxState, CID) (uint32, error)) *TxStore_CountTransactionsByState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// CountUnconfirmedTransactions provides a mock function with given fields: ctx, fromAddress, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CountUnconfirmedTransactions(ctx context.Context, fromAddress ADDR, chainID CID) (uint32, error) {
	ret := _m.Called(ctx, fromAddress, chainID)

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

	var r0 uint32
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) (uint32, error)); ok {
		return rf(ctx, fromAddress, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) uint32); ok {
		r0 = rf(ctx, fromAddress, chainID)
	} else {
		r0 = ret.Get(0).(uint32)
	}

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

	return r0, r1
}

// TxStore_CountUnconfirmedTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountUnconfirmedTransactions'
type TxStore_CountUnconfirmedTransactions_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// CountUnconfirmedTransactions is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CountUnconfirmedTransactions(ctx interface{}, fromAddress interface{}, chainID interface{}) *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("CountUnconfirmedTransactions", ctx, fromAddress, chainID)}
}

func (_c *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, chainID CID)) *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(count uint32, err error) *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(count, err)
	return _c
}

func (_c *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) (uint32, error)) *TxStore_CountUnconfirmedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// CountUnstartedTransactions provides a mock function with given fields: ctx, fromAddress, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CountUnstartedTransactions(ctx context.Context, fromAddress ADDR, chainID CID) (uint32, error) {
	ret := _m.Called(ctx, fromAddress, chainID)

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

	var r0 uint32
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) (uint32, error)); ok {
		return rf(ctx, fromAddress, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) uint32); ok {
		r0 = rf(ctx, fromAddress, chainID)
	} else {
		r0 = ret.Get(0).(uint32)
	}

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

	return r0, r1
}

// TxStore_CountUnstartedTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountUnstartedTransactions'
type TxStore_CountUnstartedTransactions_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// CountUnstartedTransactions is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CountUnstartedTransactions(ctx interface{}, fromAddress interface{}, chainID interface{}) *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("CountUnstartedTransactions", ctx, fromAddress, chainID)}
}

func (_c *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, chainID CID)) *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(count uint32, err error) *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(count, err)
	return _c
}

func (_c *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) (uint32, error)) *TxStore_CountUnstartedTransactions_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// CreateTransaction provides a mock function with given fields: ctx, txRequest, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CreateTransaction(ctx context.Context, txRequest types.TxRequest[ADDR, THASH], chainID CID) (types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, txRequest, chainID)

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

	var r0 types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.TxRequest[ADDR, THASH], CID) (types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, txRequest, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.TxRequest[ADDR, THASH], CID) types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, txRequest, chainID)
	} else {
		r0 = ret.Get(0).(types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.TxRequest[ADDR, THASH], CID) error); ok {
		r1 = rf(ctx, txRequest, chainID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_CreateTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransaction'
type TxStore_CreateTransaction_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// CreateTransaction is a helper method to define mock.On call
//   - ctx context.Context
//   - txRequest types.TxRequest[ADDR,THASH]
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) CreateTransaction(ctx interface{}, txRequest interface{}, chainID interface{}) *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("CreateTransaction", ctx, txRequest, chainID)}
}

func (_c *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, txRequest types.TxRequest[ADDR, THASH], chainID CID)) *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.TxRequest[ADDR, THASH]), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, types.TxRequest[ADDR, THASH], CID) (types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_CreateTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// DeleteInProgressAttempt provides a mock function with given fields: ctx, attempt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) DeleteInProgressAttempt(ctx context.Context, attempt types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, attempt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, attempt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_DeleteInProgressAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInProgressAttempt'
type TxStore_DeleteInProgressAttempt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// DeleteInProgressAttempt is a helper method to define mock.On call
//   - ctx context.Context
//   - attempt types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) DeleteInProgressAttempt(ctx interface{}, attempt interface{}) *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("DeleteInProgressAttempt", ctx, attempt)}
}

func (_c *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, attempt types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_DeleteInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindEarliestUnconfirmedBroadcastTime provides a mock function with given fields: ctx, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindEarliestUnconfirmedBroadcastTime(ctx context.Context, chainID CID) (null.Time, error) {
	ret := _m.Called(ctx, chainID)

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

	var r0 null.Time
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CID) (null.Time, error)); ok {
		return rf(ctx, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CID) null.Time); ok {
		r0 = rf(ctx, chainID)
	} else {
		r0 = ret.Get(0).(null.Time)
	}

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

	return r0, r1
}

// TxStore_FindEarliestUnconfirmedBroadcastTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindEarliestUnconfirmedBroadcastTime'
type TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindEarliestUnconfirmedBroadcastTime is a helper method to define mock.On call
//   - ctx context.Context
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindEarliestUnconfirmedBroadcastTime(ctx interface{}, chainID interface{}) *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindEarliestUnconfirmedBroadcastTime", ctx, chainID)}
}

func (_c *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, chainID CID)) *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CID))
	})
	return _c
}

func (_c *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 null.Time, _a1 error) *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, CID) (null.Time, error)) *TxStore_FindEarliestUnconfirmedBroadcastTime_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindEarliestUnconfirmedTxAttemptBlock provides a mock function with given fields: ctx, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindEarliestUnconfirmedTxAttemptBlock(ctx context.Context, chainID CID) (null.Int, error) {
	ret := _m.Called(ctx, chainID)

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

	var r0 null.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CID) (null.Int, error)); ok {
		return rf(ctx, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CID) null.Int); ok {
		r0 = rf(ctx, chainID)
	} else {
		r0 = ret.Get(0).(null.Int)
	}

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

	return r0, r1
}

// TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindEarliestUnconfirmedTxAttemptBlock'
type TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindEarliestUnconfirmedTxAttemptBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindEarliestUnconfirmedTxAttemptBlock(ctx interface{}, chainID interface{}) *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindEarliestUnconfirmedTxAttemptBlock", ctx, chainID)}
}

func (_c *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, chainID CID)) *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CID))
	})
	return _c
}

func (_c *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 null.Int, _a1 error) *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, CID) (null.Int, error)) *TxStore_FindEarliestUnconfirmedTxAttemptBlock_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindLatestSequence provides a mock function with given fields: ctx, fromAddress, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindLatestSequence(ctx context.Context, fromAddress ADDR, chainID CID) (SEQ, error) {
	ret := _m.Called(ctx, fromAddress, chainID)

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

	var r0 SEQ
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) (SEQ, error)); ok {
		return rf(ctx, fromAddress, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) SEQ); ok {
		r0 = rf(ctx, fromAddress, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(SEQ)
		}
	}

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

	return r0, r1
}

// TxStore_FindLatestSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindLatestSequence'
type TxStore_FindLatestSequence_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindLatestSequence is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindLatestSequence(ctx interface{}, fromAddress interface{}, chainID interface{}) *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindLatestSequence", ctx, fromAddress, chainID)}
}

func (_c *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, chainID CID)) *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 SEQ, _a1 error) *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) (SEQ, error)) *TxStore_FindLatestSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindNextUnstartedTransactionFromAddress provides a mock function with given fields: ctx, fromAddress, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindNextUnstartedTransactionFromAddress(ctx context.Context, fromAddress ADDR, chainID CID) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, fromAddress, chainID)

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

	var r0 *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, fromAddress, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, fromAddress, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_FindNextUnstartedTransactionFromAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindNextUnstartedTransactionFromAddress'
type TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindNextUnstartedTransactionFromAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindNextUnstartedTransactionFromAddress(ctx interface{}, fromAddress interface{}, chainID interface{}) *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindNextUnstartedTransactionFromAddress", ctx, fromAddress, chainID)}
}

func (_c *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, chainID CID)) *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], _a1 error) *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindNextUnstartedTransactionFromAddress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindReceiptWithIdempotencyKey provides a mock function with given fields: ctx, idempotencyKey, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindReceiptWithIdempotencyKey(ctx context.Context, idempotencyKey string, chainID CID) (types.ChainReceipt[THASH, BHASH], error) {
	ret := _m.Called(ctx, idempotencyKey, chainID)

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

	var r0 types.ChainReceipt[THASH, BHASH]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, CID) (types.ChainReceipt[THASH, BHASH], error)); ok {
		return rf(ctx, idempotencyKey, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, CID) types.ChainReceipt[THASH, BHASH]); ok {
		r0 = rf(ctx, idempotencyKey, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.ChainReceipt[THASH, BHASH])
		}
	}

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

	return r0, r1
}

// TxStore_FindReceiptWithIdempotencyKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindReceiptWithIdempotencyKey'
type TxStore_FindReceiptWithIdempotencyKey_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindReceiptWithIdempotencyKey is a helper method to define mock.On call
//   - ctx context.Context
//   - idempotencyKey string
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindReceiptWithIdempotencyKey(ctx interface{}, idempotencyKey interface{}, chainID interface{}) *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindReceiptWithIdempotencyKey", ctx, idempotencyKey, chainID)}
}

func (_c *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, idempotencyKey string, chainID CID)) *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 types.ChainReceipt[THASH, BHASH], _a1 error) *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, string, CID) (types.ChainReceipt[THASH, BHASH], error)) *TxStore_FindReceiptWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindReorgOrIncludedTxs provides a mock function with given fields: ctx, fromAddress, nonce, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindReorgOrIncludedTxs(ctx context.Context, fromAddress ADDR, nonce SEQ, chainID CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, fromAddress, nonce, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, SEQ, CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, fromAddress, nonce, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, SEQ, CID) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, fromAddress, nonce, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ADDR, SEQ, CID) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r1 = rf(ctx, fromAddress, nonce, chainID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, ADDR, SEQ, CID) error); ok {
		r2 = rf(ctx, fromAddress, nonce, chainID)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TxStore_FindReorgOrIncludedTxs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindReorgOrIncludedTxs'
type TxStore_FindReorgOrIncludedTxs_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindReorgOrIncludedTxs is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - nonce SEQ
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindReorgOrIncludedTxs(ctx interface{}, fromAddress interface{}, nonce interface{}, chainID interface{}) *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindReorgOrIncludedTxs", ctx, fromAddress, nonce, chainID)}
}

func (_c *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, nonce SEQ, chainID CID)) *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(SEQ), args[3].(CID))
	})
	return _c
}

func (_c *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(reorgTx []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], includedTxs []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(reorgTx, includedTxs, err)
	return _c
}

func (_c *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, SEQ, CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindReorgOrIncludedTxs_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxAttemptsConfirmedMissingReceipt provides a mock function with given fields: ctx, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxAttemptsConfirmedMissingReceipt(ctx context.Context, chainID CID) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, chainID)

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

	var r0 []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CID) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CID) []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_FindTxAttemptsConfirmedMissingReceipt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxAttemptsConfirmedMissingReceipt'
type TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxAttemptsConfirmedMissingReceipt is a helper method to define mock.On call
//   - ctx context.Context
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxAttemptsConfirmedMissingReceipt(ctx interface{}, chainID interface{}) *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxAttemptsConfirmedMissingReceipt", ctx, chainID)}
}

func (_c *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, chainID CID)) *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CID))
	})
	return _c
}

func (_c *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(attempts []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(attempts, err)
	return _c
}

func (_c *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, CID) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxAttemptsConfirmedMissingReceipt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxAttemptsRequiringResend provides a mock function with given fields: ctx, olderThan, maxInFlightTransactions, chainID, address
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxAttemptsRequiringResend(ctx context.Context, olderThan time.Time, maxInFlightTransactions uint32, chainID CID, address ADDR) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, olderThan, maxInFlightTransactions, chainID, address)

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

	var r0 []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, time.Time, uint32, CID, ADDR) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, olderThan, maxInFlightTransactions, chainID, address)
	}
	if rf, ok := ret.Get(0).(func(context.Context, time.Time, uint32, CID, ADDR) []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, olderThan, maxInFlightTransactions, chainID, address)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, time.Time, uint32, CID, ADDR) error); ok {
		r1 = rf(ctx, olderThan, maxInFlightTransactions, chainID, address)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_FindTxAttemptsRequiringResend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxAttemptsRequiringResend'
type TxStore_FindTxAttemptsRequiringResend_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxAttemptsRequiringResend is a helper method to define mock.On call
//   - ctx context.Context
//   - olderThan time.Time
//   - maxInFlightTransactions uint32
//   - chainID CID
//   - address ADDR
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxAttemptsRequiringResend(ctx interface{}, olderThan interface{}, maxInFlightTransactions interface{}, chainID interface{}, address interface{}) *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxAttemptsRequiringResend", ctx, olderThan, maxInFlightTransactions, chainID, address)}
}

func (_c *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, olderThan time.Time, maxInFlightTransactions uint32, chainID CID, address ADDR)) *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(time.Time), args[2].(uint32), args[3].(CID), args[4].(ADDR))
	})
	return _c
}

func (_c *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(attempts []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(attempts, err)
	return _c
}

func (_c *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, time.Time, uint32, CID, ADDR) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxAttemptsRequiringResend_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxWithIdempotencyKey provides a mock function with given fields: ctx, idempotencyKey, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxWithIdempotencyKey(ctx context.Context, idempotencyKey string, chainID CID) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, idempotencyKey, chainID)

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

	var r0 *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, CID) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, idempotencyKey, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, CID) *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, idempotencyKey, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_FindTxWithIdempotencyKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxWithIdempotencyKey'
type TxStore_FindTxWithIdempotencyKey_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxWithIdempotencyKey is a helper method to define mock.On call
//   - ctx context.Context
//   - idempotencyKey string
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxWithIdempotencyKey(ctx interface{}, idempotencyKey interface{}, chainID interface{}) *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxWithIdempotencyKey", ctx, idempotencyKey, chainID)}
}

func (_c *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, idempotencyKey string, chainID CID)) *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, string, CID) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxWithIdempotencyKey_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxWithSequence provides a mock function with given fields: ctx, fromAddress, seq
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxWithSequence(ctx context.Context, fromAddress ADDR, seq SEQ) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, fromAddress, seq)

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

	var r0 *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, SEQ) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, fromAddress, seq)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, SEQ) *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, fromAddress, seq)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_FindTxWithSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxWithSequence'
type TxStore_FindTxWithSequence_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxWithSequence is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
//   - seq SEQ
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxWithSequence(ctx interface{}, fromAddress interface{}, seq interface{}) *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxWithSequence", ctx, fromAddress, seq)}
}

func (_c *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR, seq SEQ)) *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(SEQ))
	})
	return _c
}

func (_c *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(etx, err)
	return _c
}

func (_c *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, SEQ) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxWithSequence_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxesByMetaFieldAndStates provides a mock function with given fields: ctx, metaField, metaValue, states, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesByMetaFieldAndStates(ctx context.Context, metaField string, metaValue string, states []types.TxState, chainID *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, metaField, metaValue, states, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []types.TxState, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, metaField, metaValue, states, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []types.TxState, *big.Int) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, metaField, metaValue, states, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, []types.TxState, *big.Int) error); ok {
		r1 = rf(ctx, metaField, metaValue, states, chainID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_FindTxesByMetaFieldAndStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxesByMetaFieldAndStates'
type TxStore_FindTxesByMetaFieldAndStates_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxesByMetaFieldAndStates is a helper method to define mock.On call
//   - ctx context.Context
//   - metaField string
//   - metaValue string
//   - states []types.TxState
//   - chainID *big.Int
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesByMetaFieldAndStates(ctx interface{}, metaField interface{}, metaValue interface{}, states interface{}, chainID interface{}) *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxesByMetaFieldAndStates", ctx, metaField, metaValue, states, chainID)}
}

func (_c *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, metaField string, metaValue string, states []types.TxState, chainID *big.Int)) *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]types.TxState), args[4].(*big.Int))
	})
	return _c
}

func (_c *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, string, string, []types.TxState, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxesByMetaFieldAndStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxesPendingCallback provides a mock function with given fields: ctx, latest, finalized, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesPendingCallback(ctx context.Context, latest int64, finalized int64, chainID CID) ([]types.ReceiptPlus[R], error) {
	ret := _m.Called(ctx, latest, finalized, chainID)

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

	var r0 []types.ReceiptPlus[R]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64, CID) ([]types.ReceiptPlus[R], error)); ok {
		return rf(ctx, latest, finalized, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, int64, CID) []types.ReceiptPlus[R]); ok {
		r0 = rf(ctx, latest, finalized, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.ReceiptPlus[R])
		}
	}

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

	return r0, r1
}

// TxStore_FindTxesPendingCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxesPendingCallback'
type TxStore_FindTxesPendingCallback_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxesPendingCallback is a helper method to define mock.On call
//   - ctx context.Context
//   - latest int64
//   - finalized int64
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesPendingCallback(ctx interface{}, latest interface{}, finalized interface{}, chainID interface{}) *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxesPendingCallback", ctx, latest, finalized, chainID)}
}

func (_c *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, latest int64, finalized int64, chainID CID)) *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(int64), args[3].(CID))
	})
	return _c
}

func (_c *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(receiptsPlus []types.ReceiptPlus[R], err error) *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(receiptsPlus, err)
	return _c
}

func (_c *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, int64, int64, CID) ([]types.ReceiptPlus[R], error)) *TxStore_FindTxesPendingCallback_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxesWithAttemptsAndReceiptsByIdsAndState provides a mock function with given fields: ctx, ids, states, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesWithAttemptsAndReceiptsByIdsAndState(ctx context.Context, ids []int64, states []types.TxState, chainID *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, ids, states, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []int64, []types.TxState, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, ids, states, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []int64, []types.TxState, *big.Int) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, ids, states, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []int64, []types.TxState, *big.Int) error); ok {
		r1 = rf(ctx, ids, states, chainID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxesWithAttemptsAndReceiptsByIdsAndState'
type TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxesWithAttemptsAndReceiptsByIdsAndState is a helper method to define mock.On call
//   - ctx context.Context
//   - ids []int64
//   - states []types.TxState
//   - chainID *big.Int
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesWithAttemptsAndReceiptsByIdsAndState(ctx interface{}, ids interface{}, states interface{}, chainID interface{}) *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxesWithAttemptsAndReceiptsByIdsAndState", ctx, ids, states, chainID)}
}

func (_c *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, ids []int64, states []types.TxState, chainID *big.Int)) *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]int64), args[2].([]types.TxState), args[3].(*big.Int))
	})
	return _c
}

func (_c *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []int64, []types.TxState, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxesWithMetaFieldByReceiptBlockNum provides a mock function with given fields: ctx, metaField, blockNum, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesWithMetaFieldByReceiptBlockNum(ctx context.Context, metaField string, blockNum int64, chainID *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, metaField, blockNum, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, int64, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, metaField, blockNum, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, int64, *big.Int) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, metaField, blockNum, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxesWithMetaFieldByReceiptBlockNum'
type TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxesWithMetaFieldByReceiptBlockNum is a helper method to define mock.On call
//   - ctx context.Context
//   - metaField string
//   - blockNum int64
//   - chainID *big.Int
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesWithMetaFieldByReceiptBlockNum(ctx interface{}, metaField interface{}, blockNum interface{}, chainID interface{}) *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxesWithMetaFieldByReceiptBlockNum", ctx, metaField, blockNum, chainID)}
}

func (_c *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, metaField string, blockNum int64, chainID *big.Int)) *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(*big.Int))
	})
	return _c
}

func (_c *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, string, int64, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxesWithMetaFieldByStates provides a mock function with given fields: ctx, metaField, states, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesWithMetaFieldByStates(ctx context.Context, metaField string, states []types.TxState, chainID *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, metaField, states, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []types.TxState, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, metaField, states, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []types.TxState, *big.Int) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, metaField, states, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, []types.TxState, *big.Int) error); ok {
		r1 = rf(ctx, metaField, states, chainID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_FindTxesWithMetaFieldByStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxesWithMetaFieldByStates'
type TxStore_FindTxesWithMetaFieldByStates_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxesWithMetaFieldByStates is a helper method to define mock.On call
//   - ctx context.Context
//   - metaField string
//   - states []types.TxState
//   - chainID *big.Int
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxesWithMetaFieldByStates(ctx interface{}, metaField interface{}, states interface{}, chainID interface{}) *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxesWithMetaFieldByStates", ctx, metaField, states, chainID)}
}

func (_c *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, metaField string, states []types.TxState, chainID *big.Int)) *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]types.TxState), args[3].(*big.Int))
	})
	return _c
}

func (_c *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, string, []types.TxState, *big.Int) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxesWithMetaFieldByStates_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxsRequiringGasBump provides a mock function with given fields: ctx, address, blockNum, gasBumpThreshold, depth, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxsRequiringGasBump(ctx context.Context, address ADDR, blockNum int64, gasBumpThreshold int64, depth int64, chainID CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, address, blockNum, gasBumpThreshold, depth, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, int64, int64, int64, CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, address, blockNum, gasBumpThreshold, depth, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, int64, int64, int64, CID) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, address, blockNum, gasBumpThreshold, depth, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ADDR, int64, int64, int64, CID) error); ok {
		r1 = rf(ctx, address, blockNum, gasBumpThreshold, depth, chainID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_FindTxsRequiringGasBump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxsRequiringGasBump'
type TxStore_FindTxsRequiringGasBump_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxsRequiringGasBump is a helper method to define mock.On call
//   - ctx context.Context
//   - address ADDR
//   - blockNum int64
//   - gasBumpThreshold int64
//   - depth int64
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxsRequiringGasBump(ctx interface{}, address interface{}, blockNum interface{}, gasBumpThreshold interface{}, depth interface{}, chainID interface{}) *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxsRequiringGasBump", ctx, address, blockNum, gasBumpThreshold, depth, chainID)}
}

func (_c *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, address ADDR, blockNum int64, gasBumpThreshold int64, depth int64, chainID CID)) *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(int64), args[3].(int64), args[4].(int64), args[5].(CID))
	})
	return _c
}

func (_c *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(etxs []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(etxs, err)
	return _c
}

func (_c *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, int64, int64, int64, CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxsRequiringGasBump_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// FindTxsRequiringResubmissionDueToInsufficientFunds provides a mock function with given fields: ctx, address, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxsRequiringResubmissionDueToInsufficientFunds(ctx context.Context, address ADDR, chainID CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, address, chainID)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, address, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, address, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTxsRequiringResubmissionDueToInsufficientFunds'
type TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// FindTxsRequiringResubmissionDueToInsufficientFunds is a helper method to define mock.On call
//   - ctx context.Context
//   - address ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) FindTxsRequiringResubmissionDueToInsufficientFunds(ctx interface{}, address interface{}, chainID interface{}) *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("FindTxsRequiringResubmissionDueToInsufficientFunds", ctx, address, chainID)}
}

func (_c *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, address ADDR, chainID CID)) *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(etxs []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(etxs, err)
	return _c
}

func (_c *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// GetAbandonedTransactionsByBatch provides a mock function with given fields: ctx, chainID, enabledAddrs, offset, limit
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetAbandonedTransactionsByBatch(ctx context.Context, chainID CID, enabledAddrs []ADDR, offset uint, limit uint) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, chainID, enabledAddrs, offset, limit)

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

	var r0 []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, CID, []ADDR, uint, uint) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, chainID, enabledAddrs, offset, limit)
	}
	if rf, ok := ret.Get(0).(func(context.Context, CID, []ADDR, uint, uint) []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, chainID, enabledAddrs, offset, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, CID, []ADDR, uint, uint) error); ok {
		r1 = rf(ctx, chainID, enabledAddrs, offset, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TxStore_GetAbandonedTransactionsByBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAbandonedTransactionsByBatch'
type TxStore_GetAbandonedTransactionsByBatch_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// GetAbandonedTransactionsByBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - chainID CID
//   - enabledAddrs []ADDR
//   - offset uint
//   - limit uint
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetAbandonedTransactionsByBatch(ctx interface{}, chainID interface{}, enabledAddrs interface{}, offset interface{}, limit interface{}) *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("GetAbandonedTransactionsByBatch", ctx, chainID, enabledAddrs, offset, limit)}
}

func (_c *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, chainID CID, enabledAddrs []ADDR, offset uint, limit uint)) *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(CID), args[2].([]ADDR), args[3].(uint), args[4].(uint))
	})
	return _c
}

func (_c *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(txs []*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(txs, err)
	return _c
}

func (_c *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, CID, []ADDR, uint, uint) ([]*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_GetAbandonedTransactionsByBatch_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// GetInProgressTxAttempts provides a mock function with given fields: ctx, address, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetInProgressTxAttempts(ctx context.Context, address ADDR, chainID CID) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, address, chainID)

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

	var r0 []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, address, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, address, chainID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_GetInProgressTxAttempts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInProgressTxAttempts'
type TxStore_GetInProgressTxAttempts_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// GetInProgressTxAttempts is a helper method to define mock.On call
//   - ctx context.Context
//   - address ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetInProgressTxAttempts(ctx interface{}, address interface{}, chainID interface{}) *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("GetInProgressTxAttempts", ctx, address, chainID)}
}

func (_c *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, address ADDR, chainID CID)) *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(attempts []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(attempts, err)
	return _c
}

func (_c *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) ([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_GetInProgressTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// GetTxByID provides a mock function with given fields: ctx, id
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetTxByID(ctx context.Context, id int64) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, id)

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

	var r0 *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_GetTxByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTxByID'
type TxStore_GetTxByID_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// GetTxByID is a helper method to define mock.On call
//   - ctx context.Context
//   - id int64
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetTxByID(ctx interface{}, id interface{}) *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("GetTxByID", ctx, id)}
}

func (_c *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, id int64)) *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

func (_c *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(tx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(tx, err)
	return _c
}

func (_c *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, int64) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_GetTxByID_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// GetTxInProgress provides a mock function with given fields: ctx, fromAddress
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetTxInProgress(ctx context.Context, fromAddress ADDR) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error) {
	ret := _m.Called(ctx, fromAddress)

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

	var r0 *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)); ok {
		return rf(ctx, fromAddress)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR) *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]); ok {
		r0 = rf(ctx, fromAddress)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])
		}
	}

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

	return r0, r1
}

// TxStore_GetTxInProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTxInProgress'
type TxStore_GetTxInProgress_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// GetTxInProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - fromAddress ADDR
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) GetTxInProgress(ctx interface{}, fromAddress interface{}) *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("GetTxInProgress", ctx, fromAddress)}
}

func (_c *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, fromAddress ADDR)) *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR))
	})
	return _c
}

func (_c *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], err error) *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(etx, err)
	return _c
}

func (_c *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR) (*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], error)) *TxStore_GetTxInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// HasInProgressTransaction provides a mock function with given fields: ctx, account, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) HasInProgressTransaction(ctx context.Context, account ADDR, chainID CID) (bool, error) {
	ret := _m.Called(ctx, account, chainID)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) (bool, error)); ok {
		return rf(ctx, account, chainID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ADDR, CID) bool); ok {
		r0 = rf(ctx, account, chainID)
	} else {
		r0 = ret.Get(0).(bool)
	}

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

	return r0, r1
}

// TxStore_HasInProgressTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasInProgressTransaction'
type TxStore_HasInProgressTransaction_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// HasInProgressTransaction is a helper method to define mock.On call
//   - ctx context.Context
//   - account ADDR
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) HasInProgressTransaction(ctx interface{}, account interface{}, chainID interface{}) *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("HasInProgressTransaction", ctx, account, chainID)}
}

func (_c *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, account ADDR, chainID CID)) *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ADDR), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(exists bool, err error) *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(exists, err)
	return _c
}

func (_c *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, ADDR, CID) (bool, error)) *TxStore_HasInProgressTransaction_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// LoadTxAttempts provides a mock function with given fields: ctx, etx
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) LoadTxAttempts(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, etx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, etx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_LoadTxAttempts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadTxAttempts'
type TxStore_LoadTxAttempts_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// LoadTxAttempts is a helper method to define mock.On call
//   - ctx context.Context
//   - etx *types.Tx[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) LoadTxAttempts(ctx interface{}, etx interface{}) *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("LoadTxAttempts", ctx, etx)}
}

func (_c *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_LoadTxAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// PreloadTxes provides a mock function with given fields: ctx, attempts
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) PreloadTxes(ctx context.Context, attempts []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, attempts)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, attempts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_PreloadTxes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PreloadTxes'
type TxStore_PreloadTxes_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// PreloadTxes is a helper method to define mock.On call
//   - ctx context.Context
//   - attempts []types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) PreloadTxes(ctx interface{}, attempts interface{}) *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("PreloadTxes", ctx, attempts)}
}

func (_c *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, attempts []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_PreloadTxes_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// PruneUnstartedTxQueue provides a mock function with given fields: ctx, queueSize, subject
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) PruneUnstartedTxQueue(ctx context.Context, queueSize uint32, subject uuid.UUID) ([]int64, error) {
	ret := _m.Called(ctx, queueSize, subject)

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

	var r0 []int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint32, uuid.UUID) ([]int64, error)); ok {
		return rf(ctx, queueSize, subject)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint32, uuid.UUID) []int64); ok {
		r0 = rf(ctx, queueSize, subject)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int64)
		}
	}

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

	return r0, r1
}

// TxStore_PruneUnstartedTxQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PruneUnstartedTxQueue'
type TxStore_PruneUnstartedTxQueue_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// PruneUnstartedTxQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - queueSize uint32
//   - subject uuid.UUID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) PruneUnstartedTxQueue(ctx interface{}, queueSize interface{}, subject interface{}) *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("PruneUnstartedTxQueue", ctx, queueSize, subject)}
}

func (_c *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, queueSize uint32, subject uuid.UUID)) *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint32), args[2].(uuid.UUID))
	})
	return _c
}

func (_c *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(ids []int64, err error) *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(ids, err)
	return _c
}

func (_c *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, uint32, uuid.UUID) ([]int64, error)) *TxStore_PruneUnstartedTxQueue_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// ReapTxHistory provides a mock function with given fields: ctx, timeThreshold, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) ReapTxHistory(ctx context.Context, timeThreshold time.Time, chainID CID) error {
	ret := _m.Called(ctx, timeThreshold, chainID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, time.Time, CID) error); ok {
		r0 = rf(ctx, timeThreshold, chainID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_ReapTxHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReapTxHistory'
type TxStore_ReapTxHistory_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// ReapTxHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - timeThreshold time.Time
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) ReapTxHistory(ctx interface{}, timeThreshold interface{}, chainID interface{}) *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("ReapTxHistory", ctx, timeThreshold, chainID)}
}

func (_c *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, timeThreshold time.Time, chainID CID)) *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(time.Time), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, time.Time, CID) error) *TxStore_ReapTxHistory_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SaveConfirmedAttempt provides a mock function with given fields: ctx, timeout, attempt, broadcastAt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveConfirmedAttempt(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], broadcastAt time.Time) error {
	ret := _m.Called(ctx, timeout, attempt, broadcastAt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, time.Duration, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], time.Time) error); ok {
		r0 = rf(ctx, timeout, attempt, broadcastAt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SaveConfirmedAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveConfirmedAttempt'
type TxStore_SaveConfirmedAttempt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SaveConfirmedAttempt is a helper method to define mock.On call
//   - ctx context.Context
//   - timeout time.Duration
//   - attempt *types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - broadcastAt time.Time
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveConfirmedAttempt(ctx interface{}, timeout interface{}, attempt interface{}, broadcastAt interface{}) *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SaveConfirmedAttempt", ctx, timeout, attempt, broadcastAt)}
}

func (_c *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], broadcastAt time.Time)) *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(time.Duration), args[2].(*types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[3].(time.Time))
	})
	return _c
}

func (_c *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, time.Duration, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], time.Time) error) *TxStore_SaveConfirmedAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SaveFetchedReceipts provides a mock function with given fields: ctx, r
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveFetchedReceipts(ctx context.Context, r []R) error {
	ret := _m.Called(ctx, r)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []R) error); ok {
		r0 = rf(ctx, r)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SaveFetchedReceipts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveFetchedReceipts'
type TxStore_SaveFetchedReceipts_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SaveFetchedReceipts is a helper method to define mock.On call
//   - ctx context.Context
//   - r []R
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveFetchedReceipts(ctx interface{}, r interface{}) *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SaveFetchedReceipts", ctx, r)}
}

func (_c *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, r []R)) *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]R))
	})
	return _c
}

func (_c *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []R) error) *TxStore_SaveFetchedReceipts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SaveInProgressAttempt provides a mock function with given fields: ctx, attempt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveInProgressAttempt(ctx context.Context, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, attempt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, attempt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SaveInProgressAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveInProgressAttempt'
type TxStore_SaveInProgressAttempt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SaveInProgressAttempt is a helper method to define mock.On call
//   - ctx context.Context
//   - attempt *types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveInProgressAttempt(ctx interface{}, attempt interface{}) *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SaveInProgressAttempt", ctx, attempt)}
}

func (_c *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_SaveInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SaveInsufficientFundsAttempt provides a mock function with given fields: ctx, timeout, attempt, broadcastAt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveInsufficientFundsAttempt(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], broadcastAt time.Time) error {
	ret := _m.Called(ctx, timeout, attempt, broadcastAt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, time.Duration, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], time.Time) error); ok {
		r0 = rf(ctx, timeout, attempt, broadcastAt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SaveInsufficientFundsAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveInsufficientFundsAttempt'
type TxStore_SaveInsufficientFundsAttempt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SaveInsufficientFundsAttempt is a helper method to define mock.On call
//   - ctx context.Context
//   - timeout time.Duration
//   - attempt *types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - broadcastAt time.Time
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveInsufficientFundsAttempt(ctx interface{}, timeout interface{}, attempt interface{}, broadcastAt interface{}) *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SaveInsufficientFundsAttempt", ctx, timeout, attempt, broadcastAt)}
}

func (_c *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], broadcastAt time.Time)) *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(time.Duration), args[2].(*types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[3].(time.Time))
	})
	return _c
}

func (_c *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, time.Duration, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], time.Time) error) *TxStore_SaveInsufficientFundsAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SaveReplacementInProgressAttempt provides a mock function with given fields: ctx, oldAttempt, replacementAttempt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveReplacementInProgressAttempt(ctx context.Context, oldAttempt types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], replacementAttempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, oldAttempt, replacementAttempt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, oldAttempt, replacementAttempt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SaveReplacementInProgressAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveReplacementInProgressAttempt'
type TxStore_SaveReplacementInProgressAttempt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SaveReplacementInProgressAttempt is a helper method to define mock.On call
//   - ctx context.Context
//   - oldAttempt types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - replacementAttempt *types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveReplacementInProgressAttempt(ctx interface{}, oldAttempt interface{}, replacementAttempt interface{}) *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SaveReplacementInProgressAttempt", ctx, oldAttempt, replacementAttempt)}
}

func (_c *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, oldAttempt types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], replacementAttempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[2].(*types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_SaveReplacementInProgressAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SaveSentAttempt provides a mock function with given fields: ctx, timeout, attempt, broadcastAt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveSentAttempt(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], broadcastAt time.Time) error {
	ret := _m.Called(ctx, timeout, attempt, broadcastAt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, time.Duration, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], time.Time) error); ok {
		r0 = rf(ctx, timeout, attempt, broadcastAt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SaveSentAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSentAttempt'
type TxStore_SaveSentAttempt_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SaveSentAttempt is a helper method to define mock.On call
//   - ctx context.Context
//   - timeout time.Duration
//   - attempt *types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - broadcastAt time.Time
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SaveSentAttempt(ctx interface{}, timeout interface{}, attempt interface{}, broadcastAt interface{}) *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SaveSentAttempt", ctx, timeout, attempt, broadcastAt)}
}

func (_c *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], broadcastAt time.Time)) *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(time.Duration), args[2].(*types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[3].(time.Time))
	})
	return _c
}

func (_c *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, time.Duration, *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], time.Time) error) *TxStore_SaveSentAttempt_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// SetBroadcastBeforeBlockNum provides a mock function with given fields: ctx, blockNum, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SetBroadcastBeforeBlockNum(ctx context.Context, blockNum int64, chainID CID) error {
	ret := _m.Called(ctx, blockNum, chainID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, CID) error); ok {
		r0 = rf(ctx, blockNum, chainID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_SetBroadcastBeforeBlockNum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBroadcastBeforeBlockNum'
type TxStore_SetBroadcastBeforeBlockNum_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// SetBroadcastBeforeBlockNum is a helper method to define mock.On call
//   - ctx context.Context
//   - blockNum int64
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) SetBroadcastBeforeBlockNum(ctx interface{}, blockNum interface{}, chainID interface{}) *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("SetBroadcastBeforeBlockNum", ctx, blockNum, chainID)}
}

func (_c *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, blockNum int64, chainID CID)) *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, int64, CID) error) *TxStore_SetBroadcastBeforeBlockNum_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateBroadcastAts provides a mock function with given fields: ctx, now, etxIDs
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateBroadcastAts(ctx context.Context, now time.Time, etxIDs []int64) error {
	ret := _m.Called(ctx, now, etxIDs)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, time.Time, []int64) error); ok {
		r0 = rf(ctx, now, etxIDs)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateBroadcastAts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBroadcastAts'
type TxStore_UpdateBroadcastAts_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateBroadcastAts is a helper method to define mock.On call
//   - ctx context.Context
//   - now time.Time
//   - etxIDs []int64
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateBroadcastAts(ctx interface{}, now interface{}, etxIDs interface{}) *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateBroadcastAts", ctx, now, etxIDs)}
}

func (_c *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, now time.Time, etxIDs []int64)) *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(time.Time), args[2].([]int64))
	})
	return _c
}

func (_c *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, time.Time, []int64) error) *TxStore_UpdateBroadcastAts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxAttemptInProgressToBroadcast provides a mock function with given fields: ctx, etx, attempt, NewAttemptState
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxAttemptInProgressToBroadcast(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], attempt types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], NewAttemptState types.TxAttemptState) error {
	ret := _m.Called(ctx, etx, attempt, NewAttemptState)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], types.TxAttemptState) error); ok {
		r0 = rf(ctx, etx, attempt, NewAttemptState)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxAttemptInProgressToBroadcast_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxAttemptInProgressToBroadcast'
type TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxAttemptInProgressToBroadcast is a helper method to define mock.On call
//   - ctx context.Context
//   - etx *types.Tx[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - attempt types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - NewAttemptState types.TxAttemptState
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxAttemptInProgressToBroadcast(ctx interface{}, etx interface{}, attempt interface{}, NewAttemptState interface{}) *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxAttemptInProgressToBroadcast", ctx, etx, attempt, NewAttemptState)}
}

func (_c *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], attempt types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], NewAttemptState types.TxAttemptState)) *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[2].(types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[3].(types.TxAttemptState))
	})
	return _c
}

func (_c *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE], types.TxAttemptState) error) *TxStore_UpdateTxAttemptInProgressToBroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxCallbackCompleted provides a mock function with given fields: ctx, pipelineTaskRunRid, chainID
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxCallbackCompleted(ctx context.Context, pipelineTaskRunRid uuid.UUID, chainID CID) error {
	ret := _m.Called(ctx, pipelineTaskRunRid, chainID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, CID) error); ok {
		r0 = rf(ctx, pipelineTaskRunRid, chainID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxCallbackCompleted_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxCallbackCompleted'
type TxStore_UpdateTxCallbackCompleted_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxCallbackCompleted is a helper method to define mock.On call
//   - ctx context.Context
//   - pipelineTaskRunRid uuid.UUID
//   - chainID CID
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxCallbackCompleted(ctx interface{}, pipelineTaskRunRid interface{}, chainID interface{}) *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxCallbackCompleted", ctx, pipelineTaskRunRid, chainID)}
}

func (_c *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, pipelineTaskRunRid uuid.UUID, chainID CID)) *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID), args[2].(CID))
	})
	return _c
}

func (_c *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, uuid.UUID, CID) error) *TxStore_UpdateTxCallbackCompleted_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxConfirmed provides a mock function with given fields: ctx, etxIDs
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxConfirmed(ctx context.Context, etxIDs []int64) error {
	ret := _m.Called(ctx, etxIDs)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []int64) error); ok {
		r0 = rf(ctx, etxIDs)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxConfirmed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxConfirmed'
type TxStore_UpdateTxConfirmed_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxConfirmed is a helper method to define mock.On call
//   - ctx context.Context
//   - etxIDs []int64
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxConfirmed(ctx interface{}, etxIDs interface{}) *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxConfirmed", ctx, etxIDs)}
}

func (_c *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etxIDs []int64)) *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]int64))
	})
	return _c
}

func (_c *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []int64) error) *TxStore_UpdateTxConfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxFatalError provides a mock function with given fields: ctx, etxIDs, errMsg
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxFatalError(ctx context.Context, etxIDs []int64, errMsg string) error {
	ret := _m.Called(ctx, etxIDs, errMsg)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []int64, string) error); ok {
		r0 = rf(ctx, etxIDs, errMsg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxFatalError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxFatalError'
type TxStore_UpdateTxFatalError_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxFatalError is a helper method to define mock.On call
//   - ctx context.Context
//   - etxIDs []int64
//   - errMsg string
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxFatalError(ctx interface{}, etxIDs interface{}, errMsg interface{}) *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxFatalError", ctx, etxIDs, errMsg)}
}

func (_c *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etxIDs []int64, errMsg string)) *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]int64), args[2].(string))
	})
	return _c
}

func (_c *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []int64, string) error) *TxStore_UpdateTxFatalError_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxFatalErrorAndDeleteAttempts provides a mock function with given fields: ctx, etx
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxFatalErrorAndDeleteAttempts(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, etx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, etx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxFatalErrorAndDeleteAttempts'
type TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxFatalErrorAndDeleteAttempts is a helper method to define mock.On call
//   - ctx context.Context
//   - etx *types.Tx[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxFatalErrorAndDeleteAttempts(ctx interface{}, etx interface{}) *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxFatalErrorAndDeleteAttempts", ctx, etx)}
}

func (_c *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_UpdateTxFatalErrorAndDeleteAttempts_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxUnstartedToInProgress provides a mock function with given fields: ctx, etx, attempt
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxUnstartedToInProgress(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error {
	ret := _m.Called(ctx, etx, attempt)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error); ok {
		r0 = rf(ctx, etx, attempt)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxUnstartedToInProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxUnstartedToInProgress'
type TxStore_UpdateTxUnstartedToInProgress_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxUnstartedToInProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - etx *types.Tx[CID,ADDR,THASH,BHASH,SEQ,FEE]
//   - attempt *types.TxAttempt[CID,ADDR,THASH,BHASH,SEQ,FEE]
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxUnstartedToInProgress(ctx interface{}, etx interface{}, attempt interface{}) *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxUnstartedToInProgress", ctx, etx, attempt)}
}

func (_c *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etx *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], attempt *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE])) *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE]), args[2].(*types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]))
	})
	return _c
}

func (_c *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, *types.Tx[CID, ADDR, THASH, BHASH, SEQ, FEE], *types.TxAttempt[CID, ADDR, THASH, BHASH, SEQ, FEE]) error) *TxStore_UpdateTxUnstartedToInProgress_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxsForRebroadcast provides a mock function with given fields: ctx, etxIDs, attemptIDs
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxsForRebroadcast(ctx context.Context, etxIDs []int64, attemptIDs []int64) error {
	ret := _m.Called(ctx, etxIDs, attemptIDs)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []int64, []int64) error); ok {
		r0 = rf(ctx, etxIDs, attemptIDs)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxsForRebroadcast_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxsForRebroadcast'
type TxStore_UpdateTxsForRebroadcast_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxsForRebroadcast is a helper method to define mock.On call
//   - ctx context.Context
//   - etxIDs []int64
//   - attemptIDs []int64
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxsForRebroadcast(ctx interface{}, etxIDs interface{}, attemptIDs interface{}) *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxsForRebroadcast", ctx, etxIDs, attemptIDs)}
}

func (_c *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etxIDs []int64, attemptIDs []int64)) *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]int64), args[2].([]int64))
	})
	return _c
}

func (_c *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []int64, []int64) error) *TxStore_UpdateTxsForRebroadcast_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// UpdateTxsUnconfirmed provides a mock function with given fields: ctx, etxIDs
func (_m *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxsUnconfirmed(ctx context.Context, etxIDs []int64) error {
	ret := _m.Called(ctx, etxIDs)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []int64) error); ok {
		r0 = rf(ctx, etxIDs)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TxStore_UpdateTxsUnconfirmed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTxsUnconfirmed'
type TxStore_UpdateTxsUnconfirmed_Call[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee] struct {
	*mock.Call
}

// UpdateTxsUnconfirmed is a helper method to define mock.On call
//   - ctx context.Context
//   - etxIDs []int64
func (_e *TxStore_Expecter[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) UpdateTxsUnconfirmed(ctx interface{}, etxIDs interface{}) *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	return &TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{Call: _e.mock.On("UpdateTxsUnconfirmed", ctx, etxIDs)}
}

func (_c *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Run(run func(ctx context.Context, etxIDs []int64)) *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]int64))
	})
	return _c
}

func (_c *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) Return(_a0 error) *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE]) RunAndReturn(run func(context.Context, []int64) error) *TxStore_UpdateTxsUnconfirmed_Call[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	_c.Call.Return(run)
	return _c
}

// NewTxStore creates a new instance of TxStore. 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 NewTxStore[ADDR chains.Hashable, CID chains.ID, THASH chains.Hashable, BHASH chains.Hashable, R types.ChainReceipt[THASH, BHASH], SEQ chains.Sequence, FEE fees.Fee](t interface {
	mock.TestingT
	Cleanup(func())
}) *TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE] {
	mock := &TxStore[ADDR, CID, THASH, BHASH, R, SEQ, FEE]{}
	mock.Mock.Test(t)

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

	return mock
}
