mocks

func (*EvmTxStore) Abandon ¶

func (_m *EvmTxStore) Abandon(ctx context.Context, id *big.Int, addr common.Address) error

Abandon provides a mock function with given fields: ctx, id, addr

func (*EvmTxStore) CheckTxQueueCapacity ¶

func (_m *EvmTxStore) CheckTxQueueCapacity(ctx context.Context, fromAddress common.Address, maxQueuedTransactions uint64, chainID *big.Int) error

CheckTxQueueCapacity provides a mock function with given fields: ctx, fromAddress, maxQueuedTransactions, chainID

func (*EvmTxStore) Close ¶

func (_m *EvmTxStore) Close()

Close provides a mock function with no fields

func (*EvmTxStore) CountTransactionsByState ¶

func (_m *EvmTxStore) CountTransactionsByState(ctx context.Context, state types.TxState, chainID *big.Int) (uint32, error)

CountTransactionsByState provides a mock function with given fields: ctx, state, chainID

func (*EvmTxStore) CountUnconfirmedTransactions ¶

func (_m *EvmTxStore) CountUnconfirmedTransactions(ctx context.Context, fromAddress common.Address, chainID *big.Int) (uint32, error)

CountUnconfirmedTransactions provides a mock function with given fields: ctx, fromAddress, chainID

func (*EvmTxStore) CountUnstartedTransactions ¶

func (_m *EvmTxStore) CountUnstartedTransactions(ctx context.Context, fromAddress common.Address, chainID *big.Int) (uint32, error)

CountUnstartedTransactions provides a mock function with given fields: ctx, fromAddress, chainID

func (*EvmTxStore) CreateTransaction ¶

func (_m *EvmTxStore) CreateTransaction(ctx context.Context, txRequest types.TxRequest[common.Address, common.Hash], chainID *big.Int) (types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

CreateTransaction provides a mock function with given fields: ctx, txRequest, chainID

func (*EvmTxStore) DeleteInProgressAttempt ¶

func (_m *EvmTxStore) DeleteInProgressAttempt(ctx context.Context, attempt types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

DeleteInProgressAttempt provides a mock function with given fields: ctx, attempt

func (*EvmTxStore) DeleteReceiptByTxHash ¶

func (_m *EvmTxStore) DeleteReceiptByTxHash(ctx context.Context, txHash common.Hash) error

DeleteReceiptByTxHash provides a mock function with given fields: ctx, txHash

func (*EvmTxStore) EXPECT ¶

func (_m *EvmTxStore) EXPECT() *EvmTxStore_Expecter

func (*EvmTxStore) FindAttemptsRequiringReceiptFetch ¶

func (_m *EvmTxStore) FindAttemptsRequiringReceiptFetch(ctx context.Context, chainID *big.Int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindAttemptsRequiringReceiptFetch provides a mock function with given fields: ctx, chainID

func (*EvmTxStore) FindConfirmedTxesReceipts ¶

func (_m *EvmTxStore) FindConfirmedTxesReceipts(ctx context.Context, finalizedBlockNum int64, chainID *big.Int) ([]*pkgtypes.Receipt, error)

FindConfirmedTxesReceipts provides a mock function with given fields: ctx, finalizedBlockNum, chainID

func (*EvmTxStore) FindEarliestUnconfirmedBroadcastTime ¶

func (_m *EvmTxStore) FindEarliestUnconfirmedBroadcastTime(ctx context.Context, chainID *big.Int) (null.Time, error)

FindEarliestUnconfirmedBroadcastTime provides a mock function with given fields: ctx, chainID

func (*EvmTxStore) FindEarliestUnconfirmedTxAttemptBlock ¶

func (_m *EvmTxStore) FindEarliestUnconfirmedTxAttemptBlock(ctx context.Context, chainID *big.Int) (null.Int, error)

FindEarliestUnconfirmedTxAttemptBlock provides a mock function with given fields: ctx, chainID

func (*EvmTxStore) FindLatestSequence ¶

func (_m *EvmTxStore) FindLatestSequence(ctx context.Context, fromAddress common.Address, chainID *big.Int) (pkgtypes.Nonce, error)

FindLatestSequence provides a mock function with given fields: ctx, fromAddress, chainID

func (*EvmTxStore) FindNextUnstartedTransactionFromAddress ¶

func (_m *EvmTxStore) FindNextUnstartedTransactionFromAddress(ctx context.Context, fromAddress common.Address, chainID *big.Int) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindNextUnstartedTransactionFromAddress provides a mock function with given fields: ctx, fromAddress, chainID

func (*EvmTxStore) FindReceiptWithIdempotencyKey ¶

func (_m *EvmTxStore) FindReceiptWithIdempotencyKey(ctx context.Context, idempotencyKey string, chainID *big.Int) (types.ChainReceipt[common.Hash, common.Hash], error)

FindReceiptWithIdempotencyKey provides a mock function with given fields: ctx, idempotencyKey, chainID

func (*EvmTxStore) FindReorgOrIncludedTxs ¶

func (_m *EvmTxStore) FindReorgOrIncludedTxs(ctx context.Context, fromAddress common.Address, nonce pkgtypes.Nonce, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindReorgOrIncludedTxs provides a mock function with given fields: ctx, fromAddress, nonce, chainID

func (*EvmTxStore) FindTxAttempt ¶

func (_m *EvmTxStore) FindTxAttempt(ctx context.Context, hash common.Hash) (*types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxAttempt provides a mock function with given fields: ctx, hash

func (*EvmTxStore) FindTxAttemptConfirmedByTxIDs ¶

func (_m *EvmTxStore) FindTxAttemptConfirmedByTxIDs(ctx context.Context, ids []int64) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxAttemptConfirmedByTxIDs provides a mock function with given fields: ctx, ids

func (*EvmTxStore) FindTxAttemptsConfirmedMissingReceipt ¶

func (_m *EvmTxStore) FindTxAttemptsConfirmedMissingReceipt(ctx context.Context, chainID *big.Int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxAttemptsConfirmedMissingReceipt provides a mock function with given fields: ctx, chainID

func (*EvmTxStore) FindTxAttemptsRequiringResend ¶

func (_m *EvmTxStore) FindTxAttemptsRequiringResend(ctx context.Context, olderThan time.Time, maxInFlightTransactions uint32, chainID *big.Int, address common.Address) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxAttemptsRequiringResend provides a mock function with given fields: ctx, olderThan, maxInFlightTransactions, chainID, address

func (*EvmTxStore) FindTxByHash ¶

func (_m *EvmTxStore) FindTxByHash(ctx context.Context, hash common.Hash) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxByHash provides a mock function with given fields: ctx, hash

func (*EvmTxStore) FindTxWithAttempts ¶

func (_m *EvmTxStore) FindTxWithAttempts(ctx context.Context, etxID int64) (types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxWithAttempts provides a mock function with given fields: ctx, etxID

func (*EvmTxStore) FindTxWithIdempotencyKey ¶

func (_m *EvmTxStore) FindTxWithIdempotencyKey(ctx context.Context, idempotencyKey string, chainID *big.Int) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxWithIdempotencyKey provides a mock function with given fields: ctx, idempotencyKey, chainID

func (*EvmTxStore) FindTxWithSequence ¶

func (_m *EvmTxStore) FindTxWithSequence(ctx context.Context, fromAddress common.Address, seq pkgtypes.Nonce) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxWithSequence provides a mock function with given fields: ctx, fromAddress, seq

func (*EvmTxStore) FindTxesByIDs ¶

func (_m *EvmTxStore) FindTxesByIDs(ctx context.Context, etxIDs []int64, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxesByIDs provides a mock function with given fields: ctx, etxIDs, chainID

func (*EvmTxStore) FindTxesByMetaFieldAndStates ¶

func (_m *EvmTxStore) FindTxesByMetaFieldAndStates(ctx context.Context, metaField string, metaValue string, states []types.TxState, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxesByMetaFieldAndStates provides a mock function with given fields: ctx, metaField, metaValue, states, chainID

func (*EvmTxStore) FindTxesPendingCallback ¶

func (_m *EvmTxStore) FindTxesPendingCallback(ctx context.Context, latest int64, finalized int64, chainID *big.Int) ([]types.ReceiptPlus[*pkgtypes.Receipt], error)

FindTxesPendingCallback provides a mock function with given fields: ctx, latest, finalized, chainID

func (*EvmTxStore) FindTxesWithAttemptsAndReceiptsByIdsAndState ¶

func (_m *EvmTxStore) FindTxesWithAttemptsAndReceiptsByIdsAndState(ctx context.Context, ids []int64, states []types.TxState, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxesWithAttemptsAndReceiptsByIdsAndState provides a mock function with given fields: ctx, ids, states, chainID

func (*EvmTxStore) FindTxesWithMetaFieldByReceiptBlockNum ¶

func (_m *EvmTxStore) FindTxesWithMetaFieldByReceiptBlockNum(ctx context.Context, metaField string, blockNum int64, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxesWithMetaFieldByReceiptBlockNum provides a mock function with given fields: ctx, metaField, blockNum, chainID

func (*EvmTxStore) FindTxesWithMetaFieldByStates ¶

func (_m *EvmTxStore) FindTxesWithMetaFieldByStates(ctx context.Context, metaField string, states []types.TxState, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxesWithMetaFieldByStates provides a mock function with given fields: ctx, metaField, states, chainID

func (*EvmTxStore) FindTxsByStateAndFromAddresses ¶

func (_m *EvmTxStore) FindTxsByStateAndFromAddresses(ctx context.Context, addresses []common.Address, state types.TxState, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxsByStateAndFromAddresses provides a mock function with given fields: ctx, addresses, state, chainID

func (*EvmTxStore) FindTxsRequiringGasBump ¶

func (_m *EvmTxStore) FindTxsRequiringGasBump(ctx context.Context, address common.Address, blockNum int64, gasBumpThreshold int64, depth int64, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxsRequiringGasBump provides a mock function with given fields: ctx, address, blockNum, gasBumpThreshold, depth, chainID

func (*EvmTxStore) FindTxsRequiringResubmissionDueToInsufficientFunds ¶

func (_m *EvmTxStore) FindTxsRequiringResubmissionDueToInsufficientFunds(ctx context.Context, address common.Address, chainID *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

FindTxsRequiringResubmissionDueToInsufficientFunds provides a mock function with given fields: ctx, address, chainID

func (*EvmTxStore) GetAbandonedTransactionsByBatch ¶

func (_m *EvmTxStore) GetAbandonedTransactionsByBatch(ctx context.Context, chainID *big.Int, enabledAddrs []common.Address, offset uint, limit uint) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

GetAbandonedTransactionsByBatch provides a mock function with given fields: ctx, chainID, enabledAddrs, offset, limit

func (*EvmTxStore) GetInProgressTxAttempts ¶

func (_m *EvmTxStore) GetInProgressTxAttempts(ctx context.Context, address common.Address, chainID *big.Int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

GetInProgressTxAttempts provides a mock function with given fields: ctx, address, chainID

func (*EvmTxStore) GetTxByID ¶

func (_m *EvmTxStore) GetTxByID(ctx context.Context, id int64) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

GetTxByID provides a mock function with given fields: ctx, id

func (*EvmTxStore) GetTxInProgress ¶

func (_m *EvmTxStore) GetTxInProgress(ctx context.Context, fromAddress common.Address) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)

GetTxInProgress provides a mock function with given fields: ctx, fromAddress

func (*EvmTxStore) HasInProgressTransaction ¶

func (_m *EvmTxStore) HasInProgressTransaction(ctx context.Context, account common.Address, chainID *big.Int) (bool, error)

HasInProgressTransaction provides a mock function with given fields: ctx, account, chainID

func (*EvmTxStore) LoadTxAttempts ¶

func (_m *EvmTxStore) LoadTxAttempts(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

LoadTxAttempts provides a mock function with given fields: ctx, etx

func (*EvmTxStore) PreloadTxes ¶

func (_m *EvmTxStore) PreloadTxes(ctx context.Context, attempts []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

PreloadTxes provides a mock function with given fields: ctx, attempts

func (*EvmTxStore) PruneUnstartedTxQueue ¶

func (_m *EvmTxStore) PruneUnstartedTxQueue(ctx context.Context, queueSize uint32, subject uuid.UUID) ([]int64, error)

PruneUnstartedTxQueue provides a mock function with given fields: ctx, queueSize, subject

func (*EvmTxStore) ReapTxHistory ¶

func (_m *EvmTxStore) ReapTxHistory(ctx context.Context, timeThreshold time.Time, chainID *big.Int) error

ReapTxHistory provides a mock function with given fields: ctx, timeThreshold, chainID

func (*EvmTxStore) SaveConfirmedAttempt ¶

func (_m *EvmTxStore) SaveConfirmedAttempt(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], broadcastAt time.Time) error

SaveConfirmedAttempt provides a mock function with given fields: ctx, timeout, attempt, broadcastAt

func (*EvmTxStore) SaveFetchedReceipts ¶

func (_m *EvmTxStore) SaveFetchedReceipts(ctx context.Context, r []*pkgtypes.Receipt) error

SaveFetchedReceipts provides a mock function with given fields: ctx, r

func (*EvmTxStore) SaveInProgressAttempt ¶

func (_m *EvmTxStore) SaveInProgressAttempt(ctx context.Context, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

SaveInProgressAttempt provides a mock function with given fields: ctx, attempt

func (*EvmTxStore) SaveInsufficientFundsAttempt ¶

func (_m *EvmTxStore) SaveInsufficientFundsAttempt(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], broadcastAt time.Time) error

SaveInsufficientFundsAttempt provides a mock function with given fields: ctx, timeout, attempt, broadcastAt

func (*EvmTxStore) SaveReplacementInProgressAttempt ¶

func (_m *EvmTxStore) SaveReplacementInProgressAttempt(ctx context.Context, oldAttempt types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], replacementAttempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

SaveReplacementInProgressAttempt provides a mock function with given fields: ctx, oldAttempt, replacementAttempt

func (*EvmTxStore) SaveSentAttempt ¶

func (_m *EvmTxStore) SaveSentAttempt(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], broadcastAt time.Time) error

SaveSentAttempt provides a mock function with given fields: ctx, timeout, attempt, broadcastAt

func (*EvmTxStore) SetBroadcastBeforeBlockNum ¶

func (_m *EvmTxStore) SetBroadcastBeforeBlockNum(ctx context.Context, blockNum int64, chainID *big.Int) error

SetBroadcastBeforeBlockNum provides a mock function with given fields: ctx, blockNum, chainID

func (*EvmTxStore) Transactions ¶

func (_m *EvmTxStore) Transactions(ctx context.Context, offset int, limit int) ([]types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], int, error)

Transactions provides a mock function with given fields: ctx, offset, limit

func (*EvmTxStore) TransactionsWithAttempts ¶

func (_m *EvmTxStore) TransactionsWithAttempts(ctx context.Context, offset int, limit int) ([]types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], int, error)

TransactionsWithAttempts provides a mock function with given fields: ctx, offset, limit

func (*EvmTxStore) TxAttempts ¶

func (_m *EvmTxStore) TxAttempts(ctx context.Context, offset int, limit int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], int, error)

TxAttempts provides a mock function with given fields: ctx, offset, limit

func (*EvmTxStore) UpdateBroadcastAts ¶

func (_m *EvmTxStore) UpdateBroadcastAts(ctx context.Context, now time.Time, etxIDs []int64) error

UpdateBroadcastAts provides a mock function with given fields: ctx, now, etxIDs

func (*EvmTxStore) UpdateTxAttemptInProgressToBroadcast ¶

func (_m *EvmTxStore) UpdateTxAttemptInProgressToBroadcast(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], attempt types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], NewAttemptState types.TxAttemptState) error

UpdateTxAttemptInProgressToBroadcast provides a mock function with given fields: ctx, etx, attempt, NewAttemptState

func (*EvmTxStore) UpdateTxCallbackCompleted ¶

func (_m *EvmTxStore) UpdateTxCallbackCompleted(ctx context.Context, pipelineTaskRunRid uuid.UUID, chainID *big.Int) error

UpdateTxCallbackCompleted provides a mock function with given fields: ctx, pipelineTaskRunRid, chainID

func (*EvmTxStore) UpdateTxConfirmed ¶

func (_m *EvmTxStore) UpdateTxConfirmed(ctx context.Context, etxIDs []int64) error

UpdateTxConfirmed provides a mock function with given fields: ctx, etxIDs

func (*EvmTxStore) UpdateTxFatalError ¶

func (_m *EvmTxStore) UpdateTxFatalError(ctx context.Context, etxIDs []int64, errMsg string) error

UpdateTxFatalError provides a mock function with given fields: ctx, etxIDs, errMsg

func (*EvmTxStore) UpdateTxFatalErrorAndDeleteAttempts ¶

func (_m *EvmTxStore) UpdateTxFatalErrorAndDeleteAttempts(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

UpdateTxFatalErrorAndDeleteAttempts provides a mock function with given fields: ctx, etx

func (*EvmTxStore) UpdateTxStatesToFinalizedUsingTxHashes ¶

func (_m *EvmTxStore) UpdateTxStatesToFinalizedUsingTxHashes(ctx context.Context, txHashes []common.Hash, chainID *big.Int) error

UpdateTxStatesToFinalizedUsingTxHashes provides a mock function with given fields: ctx, txHashes, chainID

func (*EvmTxStore) UpdateTxUnstartedToInProgress ¶

func (_m *EvmTxStore) UpdateTxUnstartedToInProgress(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error

UpdateTxUnstartedToInProgress provides a mock function with given fields: ctx, etx, attempt

func (*EvmTxStore) UpdateTxsForRebroadcast ¶

func (_m *EvmTxStore) UpdateTxsForRebroadcast(ctx context.Context, etxIDs []int64, attemptIDs []int64) error

UpdateTxsForRebroadcast provides a mock function with given fields: ctx, etxIDs, attemptIDs

func (*EvmTxStore) UpdateTxsUnconfirmed ¶

func (_m *EvmTxStore) UpdateTxsUnconfirmed(ctx context.Context, etxIDs []int64) error

UpdateTxsUnconfirmed provides a mock function with given fields: ctx, etxIDs

func (*EvmTxStore_Abandon_Call) Return ¶

func (_c *EvmTxStore_Abandon_Call) Return(_a0 error) *EvmTxStore_Abandon_Call

func (*EvmTxStore_Abandon_Call) Run ¶

func (_c *EvmTxStore_Abandon_Call) Run(run func(ctx context.Context, id *big.Int, addr common.Address)) *EvmTxStore_Abandon_Call

func (*EvmTxStore_Abandon_Call) RunAndReturn ¶

func (_c *EvmTxStore_Abandon_Call) RunAndReturn(run func(context.Context, *big.Int, common.Address) error) *EvmTxStore_Abandon_Call

func (*EvmTxStore_CheckTxQueueCapacity_Call) Return ¶

func (_c *EvmTxStore_CheckTxQueueCapacity_Call) Return(err error) *EvmTxStore_CheckTxQueueCapacity_Call

func (*EvmTxStore_CheckTxQueueCapacity_Call) Run ¶

func (_c *EvmTxStore_CheckTxQueueCapacity_Call) Run(run func(ctx context.Context, fromAddress common.Address, maxQueuedTransactions uint64, chainID *big.Int)) *EvmTxStore_CheckTxQueueCapacity_Call

func (*EvmTxStore_CheckTxQueueCapacity_Call) RunAndReturn ¶

func (_c *EvmTxStore_CheckTxQueueCapacity_Call) RunAndReturn(run func(context.Context, common.Address, uint64, *big.Int) error) *EvmTxStore_CheckTxQueueCapacity_Call

func (*EvmTxStore_Close_Call) Return ¶

func (_c *EvmTxStore_Close_Call) Return() *EvmTxStore_Close_Call

func (*EvmTxStore_Close_Call) Run ¶

func (_c *EvmTxStore_Close_Call) Run(run func()) *EvmTxStore_Close_Call

func (*EvmTxStore_Close_Call) RunAndReturn ¶

func (_c *EvmTxStore_Close_Call) RunAndReturn(run func()) *EvmTxStore_Close_Call

func (*EvmTxStore_CountTransactionsByState_Call) Return ¶

func (_c *EvmTxStore_CountTransactionsByState_Call) Return(count uint32, err error) *EvmTxStore_CountTransactionsByState_Call

func (*EvmTxStore_CountTransactionsByState_Call) Run ¶

func (_c *EvmTxStore_CountTransactionsByState_Call) Run(run func(ctx context.Context, state types.TxState, chainID *big.Int)) *EvmTxStore_CountTransactionsByState_Call

func (*EvmTxStore_CountTransactionsByState_Call) RunAndReturn ¶

func (_c *EvmTxStore_CountTransactionsByState_Call) RunAndReturn(run func(context.Context, types.TxState, *big.Int) (uint32, error)) *EvmTxStore_CountTransactionsByState_Call

func (*EvmTxStore_CountUnconfirmedTransactions_Call) Return ¶

func (_c *EvmTxStore_CountUnconfirmedTransactions_Call) Return(count uint32, err error) *EvmTxStore_CountUnconfirmedTransactions_Call

func (*EvmTxStore_CountUnconfirmedTransactions_Call) Run ¶

func (_c *EvmTxStore_CountUnconfirmedTransactions_Call) Run(run func(ctx context.Context, fromAddress common.Address, chainID *big.Int)) *EvmTxStore_CountUnconfirmedTransactions_Call

func (*EvmTxStore_CountUnconfirmedTransactions_Call) RunAndReturn ¶

func (_c *EvmTxStore_CountUnconfirmedTransactions_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (uint32, error)) *EvmTxStore_CountUnconfirmedTransactions_Call

func (*EvmTxStore_CountUnstartedTransactions_Call) Return ¶

func (_c *EvmTxStore_CountUnstartedTransactions_Call) Return(count uint32, err error) *EvmTxStore_CountUnstartedTransactions_Call

func (*EvmTxStore_CountUnstartedTransactions_Call) Run ¶

func (_c *EvmTxStore_CountUnstartedTransactions_Call) Run(run func(ctx context.Context, fromAddress common.Address, chainID *big.Int)) *EvmTxStore_CountUnstartedTransactions_Call

func (*EvmTxStore_CountUnstartedTransactions_Call) RunAndReturn ¶

func (_c *EvmTxStore_CountUnstartedTransactions_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (uint32, error)) *EvmTxStore_CountUnstartedTransactions_Call

func (*EvmTxStore_CreateTransaction_Call) Return ¶

func (_c *EvmTxStore_CreateTransaction_Call) Return(tx types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_CreateTransaction_Call

func (*EvmTxStore_CreateTransaction_Call) Run ¶

func (_c *EvmTxStore_CreateTransaction_Call) Run(run func(ctx context.Context, txRequest types.TxRequest[common.Address, common.Hash], chainID *big.Int)) *EvmTxStore_CreateTransaction_Call

func (*EvmTxStore_CreateTransaction_Call) RunAndReturn ¶

func (_c *EvmTxStore_CreateTransaction_Call) RunAndReturn(run func(context.Context, types.TxRequest[common.Address, common.Hash], *big.Int) (types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_CreateTransaction_Call

func (*EvmTxStore_DeleteInProgressAttempt_Call) Return ¶

func (_c *EvmTxStore_DeleteInProgressAttempt_Call) Return(_a0 error) *EvmTxStore_DeleteInProgressAttempt_Call

func (*EvmTxStore_DeleteInProgressAttempt_Call) Run ¶

func (_c *EvmTxStore_DeleteInProgressAttempt_Call) Run(run func(ctx context.Context, attempt types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee])) *EvmTxStore_DeleteInProgressAttempt_Call

func (*EvmTxStore_DeleteInProgressAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_DeleteInProgressAttempt_Call) RunAndReturn(run func(context.Context, types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error) *EvmTxStore_DeleteInProgressAttempt_Call

func (*EvmTxStore_DeleteReceiptByTxHash_Call) Return ¶

func (_c *EvmTxStore_DeleteReceiptByTxHash_Call) Return(_a0 error) *EvmTxStore_DeleteReceiptByTxHash_Call

func (*EvmTxStore_DeleteReceiptByTxHash_Call) Run ¶

func (_c *EvmTxStore_DeleteReceiptByTxHash_Call) Run(run func(ctx context.Context, txHash common.Hash)) *EvmTxStore_DeleteReceiptByTxHash_Call

func (*EvmTxStore_DeleteReceiptByTxHash_Call) RunAndReturn ¶

func (_c *EvmTxStore_DeleteReceiptByTxHash_Call) RunAndReturn(run func(context.Context, common.Hash) error) *EvmTxStore_DeleteReceiptByTxHash_Call

func (*EvmTxStore_Expecter) Abandon ¶

func (_e *EvmTxStore_Expecter) Abandon(ctx interface{}, id interface{}, addr interface{}) *EvmTxStore_Abandon_Call

Abandon is a helper method to define mock.On call

• ctx context.Context
• id *big.Int
• addr common.Address

func (*EvmTxStore_Expecter) CheckTxQueueCapacity ¶

func (_e *EvmTxStore_Expecter) CheckTxQueueCapacity(ctx interface{}, fromAddress interface{}, maxQueuedTransactions interface{}, chainID interface{}) *EvmTxStore_CheckTxQueueCapacity_Call

CheckTxQueueCapacity is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• maxQueuedTransactions uint64
• chainID *big.Int

func (*EvmTxStore_Expecter) Close ¶

func (_e *EvmTxStore_Expecter) Close() *EvmTxStore_Close_Call

Close is a helper method to define mock.On call

func (*EvmTxStore_Expecter) CountTransactionsByState ¶

func (_e *EvmTxStore_Expecter) CountTransactionsByState(ctx interface{}, state interface{}, chainID interface{}) *EvmTxStore_CountTransactionsByState_Call

CountTransactionsByState is a helper method to define mock.On call

• ctx context.Context
• state types.TxState
• chainID *big.Int

func (*EvmTxStore_Expecter) CountUnconfirmedTransactions ¶

func (_e *EvmTxStore_Expecter) CountUnconfirmedTransactions(ctx interface{}, fromAddress interface{}, chainID interface{}) *EvmTxStore_CountUnconfirmedTransactions_Call

CountUnconfirmedTransactions is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) CountUnstartedTransactions ¶

func (_e *EvmTxStore_Expecter) CountUnstartedTransactions(ctx interface{}, fromAddress interface{}, chainID interface{}) *EvmTxStore_CountUnstartedTransactions_Call

CountUnstartedTransactions is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) CreateTransaction ¶

func (_e *EvmTxStore_Expecter) CreateTransaction(ctx interface{}, txRequest interface{}, chainID interface{}) *EvmTxStore_CreateTransaction_Call

CreateTransaction is a helper method to define mock.On call

• ctx context.Context
• txRequest types.TxRequest[common.Address,common.Hash]
• chainID *big.Int

func (*EvmTxStore_Expecter) DeleteInProgressAttempt ¶

func (_e *EvmTxStore_Expecter) DeleteInProgressAttempt(ctx interface{}, attempt interface{}) *EvmTxStore_DeleteInProgressAttempt_Call

DeleteInProgressAttempt is a helper method to define mock.On call

• ctx context.Context
• attempt types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) DeleteReceiptByTxHash ¶

func (_e *EvmTxStore_Expecter) DeleteReceiptByTxHash(ctx interface{}, txHash interface{}) *EvmTxStore_DeleteReceiptByTxHash_Call

DeleteReceiptByTxHash is a helper method to define mock.On call

• ctx context.Context
• txHash common.Hash

func (*EvmTxStore_Expecter) FindAttemptsRequiringReceiptFetch ¶

func (_e *EvmTxStore_Expecter) FindAttemptsRequiringReceiptFetch(ctx interface{}, chainID interface{}) *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call

FindAttemptsRequiringReceiptFetch is a helper method to define mock.On call

• ctx context.Context
• chainID *big.Int

func (*EvmTxStore_Expecter) FindConfirmedTxesReceipts ¶

func (_e *EvmTxStore_Expecter) FindConfirmedTxesReceipts(ctx interface{}, finalizedBlockNum interface{}, chainID interface{}) *EvmTxStore_FindConfirmedTxesReceipts_Call

FindConfirmedTxesReceipts is a helper method to define mock.On call

• ctx context.Context
• finalizedBlockNum int64
• chainID *big.Int

func (*EvmTxStore_Expecter) FindEarliestUnconfirmedBroadcastTime ¶

func (_e *EvmTxStore_Expecter) FindEarliestUnconfirmedBroadcastTime(ctx interface{}, chainID interface{}) *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call

FindEarliestUnconfirmedBroadcastTime is a helper method to define mock.On call

• ctx context.Context
• chainID *big.Int

func (*EvmTxStore_Expecter) FindEarliestUnconfirmedTxAttemptBlock ¶

func (_e *EvmTxStore_Expecter) FindEarliestUnconfirmedTxAttemptBlock(ctx interface{}, chainID interface{}) *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call

FindEarliestUnconfirmedTxAttemptBlock is a helper method to define mock.On call

• ctx context.Context
• chainID *big.Int

func (*EvmTxStore_Expecter) FindLatestSequence ¶

func (_e *EvmTxStore_Expecter) FindLatestSequence(ctx interface{}, fromAddress interface{}, chainID interface{}) *EvmTxStore_FindLatestSequence_Call

FindLatestSequence is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) FindNextUnstartedTransactionFromAddress ¶

func (_e *EvmTxStore_Expecter) FindNextUnstartedTransactionFromAddress(ctx interface{}, fromAddress interface{}, chainID interface{}) *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call

FindNextUnstartedTransactionFromAddress is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) FindReceiptWithIdempotencyKey ¶

func (_e *EvmTxStore_Expecter) FindReceiptWithIdempotencyKey(ctx interface{}, idempotencyKey interface{}, chainID interface{}) *EvmTxStore_FindReceiptWithIdempotencyKey_Call

FindReceiptWithIdempotencyKey is a helper method to define mock.On call

• ctx context.Context
• idempotencyKey string
• chainID *big.Int

func (*EvmTxStore_Expecter) FindReorgOrIncludedTxs ¶

func (_e *EvmTxStore_Expecter) FindReorgOrIncludedTxs(ctx interface{}, fromAddress interface{}, nonce interface{}, chainID interface{}) *EvmTxStore_FindReorgOrIncludedTxs_Call

FindReorgOrIncludedTxs is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• nonce pkgtypes.Nonce
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxAttempt ¶

func (_e *EvmTxStore_Expecter) FindTxAttempt(ctx interface{}, hash interface{}) *EvmTxStore_FindTxAttempt_Call

FindTxAttempt is a helper method to define mock.On call

• ctx context.Context
• hash common.Hash

func (*EvmTxStore_Expecter) FindTxAttemptConfirmedByTxIDs ¶

func (_e *EvmTxStore_Expecter) FindTxAttemptConfirmedByTxIDs(ctx interface{}, ids interface{}) *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call

FindTxAttemptConfirmedByTxIDs is a helper method to define mock.On call

• ctx context.Context
• ids []int64

func (*EvmTxStore_Expecter) FindTxAttemptsConfirmedMissingReceipt ¶

func (_e *EvmTxStore_Expecter) FindTxAttemptsConfirmedMissingReceipt(ctx interface{}, chainID interface{}) *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call

FindTxAttemptsConfirmedMissingReceipt is a helper method to define mock.On call

• ctx context.Context
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxAttemptsRequiringResend ¶

func (_e *EvmTxStore_Expecter) FindTxAttemptsRequiringResend(ctx interface{}, olderThan interface{}, maxInFlightTransactions interface{}, chainID interface{}, address interface{}) *EvmTxStore_FindTxAttemptsRequiringResend_Call

FindTxAttemptsRequiringResend is a helper method to define mock.On call

• ctx context.Context
• olderThan time.Time
• maxInFlightTransactions uint32
• chainID *big.Int
• address common.Address

func (*EvmTxStore_Expecter) FindTxByHash ¶

func (_e *EvmTxStore_Expecter) FindTxByHash(ctx interface{}, hash interface{}) *EvmTxStore_FindTxByHash_Call

FindTxByHash is a helper method to define mock.On call

• ctx context.Context
• hash common.Hash

func (*EvmTxStore_Expecter) FindTxWithAttempts ¶

func (_e *EvmTxStore_Expecter) FindTxWithAttempts(ctx interface{}, etxID interface{}) *EvmTxStore_FindTxWithAttempts_Call

FindTxWithAttempts is a helper method to define mock.On call

• ctx context.Context
• etxID int64

func (*EvmTxStore_Expecter) FindTxWithIdempotencyKey ¶

func (_e *EvmTxStore_Expecter) FindTxWithIdempotencyKey(ctx interface{}, idempotencyKey interface{}, chainID interface{}) *EvmTxStore_FindTxWithIdempotencyKey_Call

FindTxWithIdempotencyKey is a helper method to define mock.On call

• ctx context.Context
• idempotencyKey string
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxWithSequence ¶

func (_e *EvmTxStore_Expecter) FindTxWithSequence(ctx interface{}, fromAddress interface{}, seq interface{}) *EvmTxStore_FindTxWithSequence_Call

FindTxWithSequence is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address
• seq pkgtypes.Nonce

func (*EvmTxStore_Expecter) FindTxesByIDs ¶

func (_e *EvmTxStore_Expecter) FindTxesByIDs(ctx interface{}, etxIDs interface{}, chainID interface{}) *EvmTxStore_FindTxesByIDs_Call

FindTxesByIDs is a helper method to define mock.On call

• ctx context.Context
• etxIDs []int64
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxesByMetaFieldAndStates ¶

func (_e *EvmTxStore_Expecter) FindTxesByMetaFieldAndStates(ctx interface{}, metaField interface{}, metaValue interface{}, states interface{}, chainID interface{}) *EvmTxStore_FindTxesByMetaFieldAndStates_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 (*EvmTxStore_Expecter) FindTxesPendingCallback ¶

func (_e *EvmTxStore_Expecter) FindTxesPendingCallback(ctx interface{}, latest interface{}, finalized interface{}, chainID interface{}) *EvmTxStore_FindTxesPendingCallback_Call

FindTxesPendingCallback is a helper method to define mock.On call

• ctx context.Context
• latest int64
• finalized int64
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxesWithAttemptsAndReceiptsByIdsAndState ¶

func (_e *EvmTxStore_Expecter) FindTxesWithAttemptsAndReceiptsByIdsAndState(ctx interface{}, ids interface{}, states interface{}, chainID interface{}) *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call

FindTxesWithAttemptsAndReceiptsByIdsAndState is a helper method to define mock.On call

• ctx context.Context
• ids []int64
• states []types.TxState
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxesWithMetaFieldByReceiptBlockNum ¶

func (_e *EvmTxStore_Expecter) FindTxesWithMetaFieldByReceiptBlockNum(ctx interface{}, metaField interface{}, blockNum interface{}, chainID interface{}) *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call

FindTxesWithMetaFieldByReceiptBlockNum is a helper method to define mock.On call

• ctx context.Context
• metaField string
• blockNum int64
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxesWithMetaFieldByStates ¶

func (_e *EvmTxStore_Expecter) FindTxesWithMetaFieldByStates(ctx interface{}, metaField interface{}, states interface{}, chainID interface{}) *EvmTxStore_FindTxesWithMetaFieldByStates_Call

FindTxesWithMetaFieldByStates is a helper method to define mock.On call

• ctx context.Context
• metaField string
• states []types.TxState
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxsByStateAndFromAddresses ¶

func (_e *EvmTxStore_Expecter) FindTxsByStateAndFromAddresses(ctx interface{}, addresses interface{}, state interface{}, chainID interface{}) *EvmTxStore_FindTxsByStateAndFromAddresses_Call

FindTxsByStateAndFromAddresses is a helper method to define mock.On call

• ctx context.Context
• addresses []common.Address
• state types.TxState
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxsRequiringGasBump ¶

func (_e *EvmTxStore_Expecter) FindTxsRequiringGasBump(ctx interface{}, address interface{}, blockNum interface{}, gasBumpThreshold interface{}, depth interface{}, chainID interface{}) *EvmTxStore_FindTxsRequiringGasBump_Call

FindTxsRequiringGasBump is a helper method to define mock.On call

• ctx context.Context
• address common.Address
• blockNum int64
• gasBumpThreshold int64
• depth int64
• chainID *big.Int

func (*EvmTxStore_Expecter) FindTxsRequiringResubmissionDueToInsufficientFunds ¶

func (_e *EvmTxStore_Expecter) FindTxsRequiringResubmissionDueToInsufficientFunds(ctx interface{}, address interface{}, chainID interface{}) *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call

FindTxsRequiringResubmissionDueToInsufficientFunds is a helper method to define mock.On call

• ctx context.Context
• address common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) GetAbandonedTransactionsByBatch ¶

func (_e *EvmTxStore_Expecter) GetAbandonedTransactionsByBatch(ctx interface{}, chainID interface{}, enabledAddrs interface{}, offset interface{}, limit interface{}) *EvmTxStore_GetAbandonedTransactionsByBatch_Call

GetAbandonedTransactionsByBatch is a helper method to define mock.On call

• ctx context.Context
• chainID *big.Int
• enabledAddrs []common.Address
• offset uint
• limit uint

func (*EvmTxStore_Expecter) GetInProgressTxAttempts ¶

func (_e *EvmTxStore_Expecter) GetInProgressTxAttempts(ctx interface{}, address interface{}, chainID interface{}) *EvmTxStore_GetInProgressTxAttempts_Call

GetInProgressTxAttempts is a helper method to define mock.On call

• ctx context.Context
• address common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) GetTxByID ¶

func (_e *EvmTxStore_Expecter) GetTxByID(ctx interface{}, id interface{}) *EvmTxStore_GetTxByID_Call

GetTxByID is a helper method to define mock.On call

• ctx context.Context
• id int64

func (*EvmTxStore_Expecter) GetTxInProgress ¶

func (_e *EvmTxStore_Expecter) GetTxInProgress(ctx interface{}, fromAddress interface{}) *EvmTxStore_GetTxInProgress_Call

GetTxInProgress is a helper method to define mock.On call

• ctx context.Context
• fromAddress common.Address

func (*EvmTxStore_Expecter) HasInProgressTransaction ¶

func (_e *EvmTxStore_Expecter) HasInProgressTransaction(ctx interface{}, account interface{}, chainID interface{}) *EvmTxStore_HasInProgressTransaction_Call

HasInProgressTransaction is a helper method to define mock.On call

• ctx context.Context
• account common.Address
• chainID *big.Int

func (*EvmTxStore_Expecter) LoadTxAttempts ¶

func (_e *EvmTxStore_Expecter) LoadTxAttempts(ctx interface{}, etx interface{}) *EvmTxStore_LoadTxAttempts_Call

LoadTxAttempts is a helper method to define mock.On call

• ctx context.Context
• etx *types.Tx[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) PreloadTxes ¶

func (_e *EvmTxStore_Expecter) PreloadTxes(ctx interface{}, attempts interface{}) *EvmTxStore_PreloadTxes_Call

PreloadTxes is a helper method to define mock.On call

• ctx context.Context
• attempts []types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) PruneUnstartedTxQueue ¶

func (_e *EvmTxStore_Expecter) PruneUnstartedTxQueue(ctx interface{}, queueSize interface{}, subject interface{}) *EvmTxStore_PruneUnstartedTxQueue_Call

PruneUnstartedTxQueue is a helper method to define mock.On call

• ctx context.Context
• queueSize uint32
• subject uuid.UUID

func (*EvmTxStore_Expecter) ReapTxHistory ¶

func (_e *EvmTxStore_Expecter) ReapTxHistory(ctx interface{}, timeThreshold interface{}, chainID interface{}) *EvmTxStore_ReapTxHistory_Call

ReapTxHistory is a helper method to define mock.On call

• ctx context.Context
• timeThreshold time.Time
• chainID *big.Int

func (*EvmTxStore_Expecter) SaveConfirmedAttempt ¶

func (_e *EvmTxStore_Expecter) SaveConfirmedAttempt(ctx interface{}, timeout interface{}, attempt interface{}, broadcastAt interface{}) *EvmTxStore_SaveConfirmedAttempt_Call

SaveConfirmedAttempt is a helper method to define mock.On call

• ctx context.Context
• timeout time.Duration
• attempt *types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• broadcastAt time.Time

func (*EvmTxStore_Expecter) SaveFetchedReceipts ¶

func (_e *EvmTxStore_Expecter) SaveFetchedReceipts(ctx interface{}, r interface{}) *EvmTxStore_SaveFetchedReceipts_Call

SaveFetchedReceipts is a helper method to define mock.On call

• ctx context.Context
• r []*pkgtypes.Receipt

func (*EvmTxStore_Expecter) SaveInProgressAttempt ¶

func (_e *EvmTxStore_Expecter) SaveInProgressAttempt(ctx interface{}, attempt interface{}) *EvmTxStore_SaveInProgressAttempt_Call

SaveInProgressAttempt is a helper method to define mock.On call

• ctx context.Context
• attempt *types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) SaveInsufficientFundsAttempt ¶

func (_e *EvmTxStore_Expecter) SaveInsufficientFundsAttempt(ctx interface{}, timeout interface{}, attempt interface{}, broadcastAt interface{}) *EvmTxStore_SaveInsufficientFundsAttempt_Call

SaveInsufficientFundsAttempt is a helper method to define mock.On call

• ctx context.Context
• timeout time.Duration
• attempt *types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• broadcastAt time.Time

func (*EvmTxStore_Expecter) SaveReplacementInProgressAttempt ¶

func (_e *EvmTxStore_Expecter) SaveReplacementInProgressAttempt(ctx interface{}, oldAttempt interface{}, replacementAttempt interface{}) *EvmTxStore_SaveReplacementInProgressAttempt_Call

SaveReplacementInProgressAttempt is a helper method to define mock.On call

• ctx context.Context
• oldAttempt types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• replacementAttempt *types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) SaveSentAttempt ¶

func (_e *EvmTxStore_Expecter) SaveSentAttempt(ctx interface{}, timeout interface{}, attempt interface{}, broadcastAt interface{}) *EvmTxStore_SaveSentAttempt_Call

SaveSentAttempt is a helper method to define mock.On call

• ctx context.Context
• timeout time.Duration
• attempt *types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• broadcastAt time.Time

func (*EvmTxStore_Expecter) SetBroadcastBeforeBlockNum ¶

func (_e *EvmTxStore_Expecter) SetBroadcastBeforeBlockNum(ctx interface{}, blockNum interface{}, chainID interface{}) *EvmTxStore_SetBroadcastBeforeBlockNum_Call

SetBroadcastBeforeBlockNum is a helper method to define mock.On call

• ctx context.Context
• blockNum int64
• chainID *big.Int

func (*EvmTxStore_Expecter) Transactions ¶

func (_e *EvmTxStore_Expecter) Transactions(ctx interface{}, offset interface{}, limit interface{}) *EvmTxStore_Transactions_Call

Transactions is a helper method to define mock.On call

• ctx context.Context
• offset int
• limit int

func (*EvmTxStore_Expecter) TransactionsWithAttempts ¶

func (_e *EvmTxStore_Expecter) TransactionsWithAttempts(ctx interface{}, offset interface{}, limit interface{}) *EvmTxStore_TransactionsWithAttempts_Call

TransactionsWithAttempts is a helper method to define mock.On call

• ctx context.Context
• offset int
• limit int

func (*EvmTxStore_Expecter) TxAttempts ¶

func (_e *EvmTxStore_Expecter) TxAttempts(ctx interface{}, offset interface{}, limit interface{}) *EvmTxStore_TxAttempts_Call

TxAttempts is a helper method to define mock.On call

• ctx context.Context
• offset int
• limit int

func (*EvmTxStore_Expecter) UpdateBroadcastAts ¶

func (_e *EvmTxStore_Expecter) UpdateBroadcastAts(ctx interface{}, now interface{}, etxIDs interface{}) *EvmTxStore_UpdateBroadcastAts_Call

UpdateBroadcastAts is a helper method to define mock.On call

• ctx context.Context
• now time.Time
• etxIDs []int64

func (*EvmTxStore_Expecter) UpdateTxAttemptInProgressToBroadcast ¶

func (_e *EvmTxStore_Expecter) UpdateTxAttemptInProgressToBroadcast(ctx interface{}, etx interface{}, attempt interface{}, NewAttemptState interface{}) *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call

UpdateTxAttemptInProgressToBroadcast is a helper method to define mock.On call

• ctx context.Context
• etx *types.Tx[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• attempt types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• NewAttemptState types.TxAttemptState

func (*EvmTxStore_Expecter) UpdateTxCallbackCompleted ¶

func (_e *EvmTxStore_Expecter) UpdateTxCallbackCompleted(ctx interface{}, pipelineTaskRunRid interface{}, chainID interface{}) *EvmTxStore_UpdateTxCallbackCompleted_Call

UpdateTxCallbackCompleted is a helper method to define mock.On call

• ctx context.Context
• pipelineTaskRunRid uuid.UUID
• chainID *big.Int

func (*EvmTxStore_Expecter) UpdateTxConfirmed ¶

func (_e *EvmTxStore_Expecter) UpdateTxConfirmed(ctx interface{}, etxIDs interface{}) *EvmTxStore_UpdateTxConfirmed_Call

UpdateTxConfirmed is a helper method to define mock.On call

• ctx context.Context
• etxIDs []int64

func (*EvmTxStore_Expecter) UpdateTxFatalError ¶

func (_e *EvmTxStore_Expecter) UpdateTxFatalError(ctx interface{}, etxIDs interface{}, errMsg interface{}) *EvmTxStore_UpdateTxFatalError_Call

UpdateTxFatalError is a helper method to define mock.On call

• ctx context.Context
• etxIDs []int64
• errMsg string

func (*EvmTxStore_Expecter) UpdateTxFatalErrorAndDeleteAttempts ¶

func (_e *EvmTxStore_Expecter) UpdateTxFatalErrorAndDeleteAttempts(ctx interface{}, etx interface{}) *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call

UpdateTxFatalErrorAndDeleteAttempts is a helper method to define mock.On call

• ctx context.Context
• etx *types.Tx[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) UpdateTxStatesToFinalizedUsingTxHashes ¶

func (_e *EvmTxStore_Expecter) UpdateTxStatesToFinalizedUsingTxHashes(ctx interface{}, txHashes interface{}, chainID interface{}) *EvmTxStore_UpdateTxStatesToFinalizedUsingTxHashes_Call

UpdateTxStatesToFinalizedUsingTxHashes is a helper method to define mock.On call

• ctx context.Context
• txHashes []common.Hash
• chainID *big.Int

func (*EvmTxStore_Expecter) UpdateTxUnstartedToInProgress ¶

func (_e *EvmTxStore_Expecter) UpdateTxUnstartedToInProgress(ctx interface{}, etx interface{}, attempt interface{}) *EvmTxStore_UpdateTxUnstartedToInProgress_Call

UpdateTxUnstartedToInProgress is a helper method to define mock.On call

• ctx context.Context
• etx *types.Tx[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]
• attempt *types.TxAttempt[*big.Int,common.Address,common.Hash,common.Hash,pkgtypes.Nonce,gas.EvmFee]

func (*EvmTxStore_Expecter) UpdateTxsForRebroadcast ¶

func (_e *EvmTxStore_Expecter) UpdateTxsForRebroadcast(ctx interface{}, etxIDs interface{}, attemptIDs interface{}) *EvmTxStore_UpdateTxsForRebroadcast_Call

UpdateTxsForRebroadcast is a helper method to define mock.On call

• ctx context.Context
• etxIDs []int64
• attemptIDs []int64

func (*EvmTxStore_Expecter) UpdateTxsUnconfirmed ¶

func (_e *EvmTxStore_Expecter) UpdateTxsUnconfirmed(ctx interface{}, etxIDs interface{}) *EvmTxStore_UpdateTxsUnconfirmed_Call

UpdateTxsUnconfirmed is a helper method to define mock.On call

• ctx context.Context
• etxIDs []int64

func (*EvmTxStore_FindAttemptsRequiringReceiptFetch_Call) Return ¶

func (_c *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call) Return(hashes []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call

func (*EvmTxStore_FindAttemptsRequiringReceiptFetch_Call) Run ¶

func (_c *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call) Run(run func(ctx context.Context, chainID *big.Int)) *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call

func (*EvmTxStore_FindAttemptsRequiringReceiptFetch_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call) RunAndReturn(run func(context.Context, *big.Int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindAttemptsRequiringReceiptFetch_Call

func (*EvmTxStore_FindConfirmedTxesReceipts_Call) Return ¶

func (_c *EvmTxStore_FindConfirmedTxesReceipts_Call) Return(receipts []*pkgtypes.Receipt, err error) *EvmTxStore_FindConfirmedTxesReceipts_Call

func (*EvmTxStore_FindConfirmedTxesReceipts_Call) Run ¶

func (_c *EvmTxStore_FindConfirmedTxesReceipts_Call) Run(run func(ctx context.Context, finalizedBlockNum int64, chainID *big.Int)) *EvmTxStore_FindConfirmedTxesReceipts_Call

func (*EvmTxStore_FindConfirmedTxesReceipts_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindConfirmedTxesReceipts_Call) RunAndReturn(run func(context.Context, int64, *big.Int) ([]*pkgtypes.Receipt, error)) *EvmTxStore_FindConfirmedTxesReceipts_Call

func (*EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call) Return ¶

func (_c *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call) Return(_a0 null.Time, _a1 error) *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call

func (*EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call) Run ¶

func (_c *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call) Run(run func(ctx context.Context, chainID *big.Int)) *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call

func (*EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call) RunAndReturn(run func(context.Context, *big.Int) (null.Time, error)) *EvmTxStore_FindEarliestUnconfirmedBroadcastTime_Call

func (*EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call) Return ¶

func (_c *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call) Return(_a0 null.Int, _a1 error) *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call

func (*EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call) Run ¶

func (_c *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call) Run(run func(ctx context.Context, chainID *big.Int)) *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call

func (*EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call) RunAndReturn(run func(context.Context, *big.Int) (null.Int, error)) *EvmTxStore_FindEarliestUnconfirmedTxAttemptBlock_Call

func (*EvmTxStore_FindLatestSequence_Call) Return ¶

func (_c *EvmTxStore_FindLatestSequence_Call) Return(_a0 pkgtypes.Nonce, _a1 error) *EvmTxStore_FindLatestSequence_Call

func (*EvmTxStore_FindLatestSequence_Call) Run ¶

func (_c *EvmTxStore_FindLatestSequence_Call) Run(run func(ctx context.Context, fromAddress common.Address, chainID *big.Int)) *EvmTxStore_FindLatestSequence_Call

func (*EvmTxStore_FindLatestSequence_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindLatestSequence_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (pkgtypes.Nonce, error)) *EvmTxStore_FindLatestSequence_Call

func (*EvmTxStore_FindNextUnstartedTransactionFromAddress_Call) Return ¶

func (_c *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call) Return(_a0 *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 error) *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call

func (*EvmTxStore_FindNextUnstartedTransactionFromAddress_Call) Run ¶

func (_c *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call) Run(run func(ctx context.Context, fromAddress common.Address, chainID *big.Int)) *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call

func (*EvmTxStore_FindNextUnstartedTransactionFromAddress_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindNextUnstartedTransactionFromAddress_Call

func (*EvmTxStore_FindReceiptWithIdempotencyKey_Call) Return ¶

func (_c *EvmTxStore_FindReceiptWithIdempotencyKey_Call) Return(_a0 types.ChainReceipt[common.Hash, common.Hash], _a1 error) *EvmTxStore_FindReceiptWithIdempotencyKey_Call

func (*EvmTxStore_FindReceiptWithIdempotencyKey_Call) Run ¶

func (_c *EvmTxStore_FindReceiptWithIdempotencyKey_Call) Run(run func(ctx context.Context, idempotencyKey string, chainID *big.Int)) *EvmTxStore_FindReceiptWithIdempotencyKey_Call

func (*EvmTxStore_FindReceiptWithIdempotencyKey_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindReceiptWithIdempotencyKey_Call) RunAndReturn(run func(context.Context, string, *big.Int) (types.ChainReceipt[common.Hash, common.Hash], error)) *EvmTxStore_FindReceiptWithIdempotencyKey_Call

func (*EvmTxStore_FindReorgOrIncludedTxs_Call) Return ¶

func (_c *EvmTxStore_FindReorgOrIncludedTxs_Call) Return(reorgTx []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], includedTxs []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindReorgOrIncludedTxs_Call

func (*EvmTxStore_FindReorgOrIncludedTxs_Call) Run ¶

func (_c *EvmTxStore_FindReorgOrIncludedTxs_Call) Run(run func(ctx context.Context, fromAddress common.Address, nonce pkgtypes.Nonce, chainID *big.Int)) *EvmTxStore_FindReorgOrIncludedTxs_Call

func (*EvmTxStore_FindReorgOrIncludedTxs_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindReorgOrIncludedTxs_Call) RunAndReturn(run func(context.Context, common.Address, pkgtypes.Nonce, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindReorgOrIncludedTxs_Call

func (*EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call) Return ¶

func (_c *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call) Return(_a0 []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 error) *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call

func (*EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call) Run ¶

func (_c *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call) Run(run func(ctx context.Context, ids []int64)) *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call

func (*EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call) RunAndReturn(run func(context.Context, []int64) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxAttemptConfirmedByTxIDs_Call

func (*EvmTxStore_FindTxAttempt_Call) Return ¶

func (_c *EvmTxStore_FindTxAttempt_Call) Return(_a0 *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 error) *EvmTxStore_FindTxAttempt_Call

func (*EvmTxStore_FindTxAttempt_Call) Run ¶

func (_c *EvmTxStore_FindTxAttempt_Call) Run(run func(ctx context.Context, hash common.Hash)) *EvmTxStore_FindTxAttempt_Call

func (*EvmTxStore_FindTxAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxAttempt_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxAttempt_Call

func (*EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call) Return ¶

func (_c *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call) Return(attempts []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call

func (*EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call) Run ¶

func (_c *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call) Run(run func(ctx context.Context, chainID *big.Int)) *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call

func (*EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call) RunAndReturn(run func(context.Context, *big.Int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxAttemptsConfirmedMissingReceipt_Call

func (*EvmTxStore_FindTxAttemptsRequiringResend_Call) Return ¶

func (_c *EvmTxStore_FindTxAttemptsRequiringResend_Call) Return(attempts []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxAttemptsRequiringResend_Call

func (*EvmTxStore_FindTxAttemptsRequiringResend_Call) Run ¶

func (_c *EvmTxStore_FindTxAttemptsRequiringResend_Call) Run(run func(ctx context.Context, olderThan time.Time, maxInFlightTransactions uint32, chainID *big.Int, address common.Address)) *EvmTxStore_FindTxAttemptsRequiringResend_Call

func (*EvmTxStore_FindTxAttemptsRequiringResend_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxAttemptsRequiringResend_Call) RunAndReturn(run func(context.Context, time.Time, uint32, *big.Int, common.Address) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxAttemptsRequiringResend_Call

func (*EvmTxStore_FindTxByHash_Call) Return ¶

func (_c *EvmTxStore_FindTxByHash_Call) Return(_a0 *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 error) *EvmTxStore_FindTxByHash_Call

func (*EvmTxStore_FindTxByHash_Call) Run ¶

func (_c *EvmTxStore_FindTxByHash_Call) Run(run func(ctx context.Context, hash common.Hash)) *EvmTxStore_FindTxByHash_Call

func (*EvmTxStore_FindTxByHash_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxByHash_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxByHash_Call

func (*EvmTxStore_FindTxWithAttempts_Call) Return ¶

func (_c *EvmTxStore_FindTxWithAttempts_Call) Return(etx types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxWithAttempts_Call

func (*EvmTxStore_FindTxWithAttempts_Call) Run ¶

func (_c *EvmTxStore_FindTxWithAttempts_Call) Run(run func(ctx context.Context, etxID int64)) *EvmTxStore_FindTxWithAttempts_Call

func (*EvmTxStore_FindTxWithAttempts_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxWithAttempts_Call) RunAndReturn(run func(context.Context, int64) (types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxWithAttempts_Call

func (*EvmTxStore_FindTxWithIdempotencyKey_Call) Return ¶

func (_c *EvmTxStore_FindTxWithIdempotencyKey_Call) Return(tx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxWithIdempotencyKey_Call

func (*EvmTxStore_FindTxWithIdempotencyKey_Call) Run ¶

func (_c *EvmTxStore_FindTxWithIdempotencyKey_Call) Run(run func(ctx context.Context, idempotencyKey string, chainID *big.Int)) *EvmTxStore_FindTxWithIdempotencyKey_Call

func (*EvmTxStore_FindTxWithIdempotencyKey_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxWithIdempotencyKey_Call) RunAndReturn(run func(context.Context, string, *big.Int) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxWithIdempotencyKey_Call

func (*EvmTxStore_FindTxWithSequence_Call) Return ¶

func (_c *EvmTxStore_FindTxWithSequence_Call) Return(etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxWithSequence_Call

func (*EvmTxStore_FindTxWithSequence_Call) Run ¶

func (_c *EvmTxStore_FindTxWithSequence_Call) Run(run func(ctx context.Context, fromAddress common.Address, seq pkgtypes.Nonce)) *EvmTxStore_FindTxWithSequence_Call

func (*EvmTxStore_FindTxWithSequence_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxWithSequence_Call) RunAndReturn(run func(context.Context, common.Address, pkgtypes.Nonce) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxWithSequence_Call

func (*EvmTxStore_FindTxesByIDs_Call) Return ¶

func (_c *EvmTxStore_FindTxesByIDs_Call) Return(etxs []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxesByIDs_Call

func (*EvmTxStore_FindTxesByIDs_Call) Run ¶

func (_c *EvmTxStore_FindTxesByIDs_Call) Run(run func(ctx context.Context, etxIDs []int64, chainID *big.Int)) *EvmTxStore_FindTxesByIDs_Call

func (*EvmTxStore_FindTxesByIDs_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxesByIDs_Call) RunAndReturn(run func(context.Context, []int64, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxesByIDs_Call

func (*EvmTxStore_FindTxesByMetaFieldAndStates_Call) Return ¶

func (_c *EvmTxStore_FindTxesByMetaFieldAndStates_Call) Return(tx []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxesByMetaFieldAndStates_Call

func (*EvmTxStore_FindTxesByMetaFieldAndStates_Call) Run ¶

func (_c *EvmTxStore_FindTxesByMetaFieldAndStates_Call) Run(run func(ctx context.Context, metaField string, metaValue string, states []types.TxState, chainID *big.Int)) *EvmTxStore_FindTxesByMetaFieldAndStates_Call

func (*EvmTxStore_FindTxesByMetaFieldAndStates_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxesByMetaFieldAndStates_Call) RunAndReturn(run func(context.Context, string, string, []types.TxState, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxesByMetaFieldAndStates_Call

func (*EvmTxStore_FindTxesPendingCallback_Call) Return ¶

func (_c *EvmTxStore_FindTxesPendingCallback_Call) Return(receiptsPlus []types.ReceiptPlus[*pkgtypes.Receipt], err error) *EvmTxStore_FindTxesPendingCallback_Call

func (*EvmTxStore_FindTxesPendingCallback_Call) Run ¶

func (_c *EvmTxStore_FindTxesPendingCallback_Call) Run(run func(ctx context.Context, latest int64, finalized int64, chainID *big.Int)) *EvmTxStore_FindTxesPendingCallback_Call

func (*EvmTxStore_FindTxesPendingCallback_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxesPendingCallback_Call) RunAndReturn(run func(context.Context, int64, int64, *big.Int) ([]types.ReceiptPlus[*pkgtypes.Receipt], error)) *EvmTxStore_FindTxesPendingCallback_Call

func (*EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call) Return ¶

func (_c *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call) Return(tx []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call

func (*EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call) Run ¶

func (_c *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call) Run(run func(ctx context.Context, ids []int64, states []types.TxState, chainID *big.Int)) *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call

func (*EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call) RunAndReturn(run func(context.Context, []int64, []types.TxState, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxesWithAttemptsAndReceiptsByIdsAndState_Call

func (*EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call) Return ¶

func (_c *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call) Return(tx []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call

func (*EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call) Run ¶

func (_c *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call) Run(run func(ctx context.Context, metaField string, blockNum int64, chainID *big.Int)) *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call

func (*EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call) RunAndReturn(run func(context.Context, string, int64, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxesWithMetaFieldByReceiptBlockNum_Call

func (*EvmTxStore_FindTxesWithMetaFieldByStates_Call) Return ¶

func (_c *EvmTxStore_FindTxesWithMetaFieldByStates_Call) Return(tx []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxesWithMetaFieldByStates_Call

func (*EvmTxStore_FindTxesWithMetaFieldByStates_Call) Run ¶

func (_c *EvmTxStore_FindTxesWithMetaFieldByStates_Call) Run(run func(ctx context.Context, metaField string, states []types.TxState, chainID *big.Int)) *EvmTxStore_FindTxesWithMetaFieldByStates_Call

func (*EvmTxStore_FindTxesWithMetaFieldByStates_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxesWithMetaFieldByStates_Call) RunAndReturn(run func(context.Context, string, []types.TxState, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxesWithMetaFieldByStates_Call

func (*EvmTxStore_FindTxsByStateAndFromAddresses_Call) Return ¶

func (_c *EvmTxStore_FindTxsByStateAndFromAddresses_Call) Return(txs []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxsByStateAndFromAddresses_Call

func (*EvmTxStore_FindTxsByStateAndFromAddresses_Call) Run ¶

func (_c *EvmTxStore_FindTxsByStateAndFromAddresses_Call) Run(run func(ctx context.Context, addresses []common.Address, state types.TxState, chainID *big.Int)) *EvmTxStore_FindTxsByStateAndFromAddresses_Call

func (*EvmTxStore_FindTxsByStateAndFromAddresses_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxsByStateAndFromAddresses_Call) RunAndReturn(run func(context.Context, []common.Address, types.TxState, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxsByStateAndFromAddresses_Call

func (*EvmTxStore_FindTxsRequiringGasBump_Call) Return ¶

func (_c *EvmTxStore_FindTxsRequiringGasBump_Call) Return(etxs []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxsRequiringGasBump_Call

func (*EvmTxStore_FindTxsRequiringGasBump_Call) Run ¶

func (_c *EvmTxStore_FindTxsRequiringGasBump_Call) Run(run func(ctx context.Context, address common.Address, blockNum int64, gasBumpThreshold int64, depth int64, chainID *big.Int)) *EvmTxStore_FindTxsRequiringGasBump_Call

func (*EvmTxStore_FindTxsRequiringGasBump_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxsRequiringGasBump_Call) RunAndReturn(run func(context.Context, common.Address, int64, int64, int64, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxsRequiringGasBump_Call

func (*EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call) Return ¶

func (_c *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call) Return(etxs []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call

func (*EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call) Run ¶

func (_c *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call) Run(run func(ctx context.Context, address common.Address, chainID *big.Int)) *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call

func (*EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call) RunAndReturn ¶

func (_c *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_FindTxsRequiringResubmissionDueToInsufficientFunds_Call

func (*EvmTxStore_GetAbandonedTransactionsByBatch_Call) Return ¶

func (_c *EvmTxStore_GetAbandonedTransactionsByBatch_Call) Return(txs []*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_GetAbandonedTransactionsByBatch_Call

func (*EvmTxStore_GetAbandonedTransactionsByBatch_Call) Run ¶

func (_c *EvmTxStore_GetAbandonedTransactionsByBatch_Call) Run(run func(ctx context.Context, chainID *big.Int, enabledAddrs []common.Address, offset uint, limit uint)) *EvmTxStore_GetAbandonedTransactionsByBatch_Call

func (*EvmTxStore_GetAbandonedTransactionsByBatch_Call) RunAndReturn ¶

func (_c *EvmTxStore_GetAbandonedTransactionsByBatch_Call) RunAndReturn(run func(context.Context, *big.Int, []common.Address, uint, uint) ([]*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_GetAbandonedTransactionsByBatch_Call

func (*EvmTxStore_GetInProgressTxAttempts_Call) Return ¶

func (_c *EvmTxStore_GetInProgressTxAttempts_Call) Return(attempts []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_GetInProgressTxAttempts_Call

func (*EvmTxStore_GetInProgressTxAttempts_Call) Run ¶

func (_c *EvmTxStore_GetInProgressTxAttempts_Call) Run(run func(ctx context.Context, address common.Address, chainID *big.Int)) *EvmTxStore_GetInProgressTxAttempts_Call

func (*EvmTxStore_GetInProgressTxAttempts_Call) RunAndReturn ¶

func (_c *EvmTxStore_GetInProgressTxAttempts_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_GetInProgressTxAttempts_Call

func (*EvmTxStore_GetTxByID_Call) Return ¶

func (_c *EvmTxStore_GetTxByID_Call) Return(tx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_GetTxByID_Call

func (*EvmTxStore_GetTxByID_Call) Run ¶

func (_c *EvmTxStore_GetTxByID_Call) Run(run func(ctx context.Context, id int64)) *EvmTxStore_GetTxByID_Call

func (*EvmTxStore_GetTxByID_Call) RunAndReturn ¶

func (_c *EvmTxStore_GetTxByID_Call) RunAndReturn(run func(context.Context, int64) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_GetTxByID_Call

func (*EvmTxStore_GetTxInProgress_Call) Return ¶

func (_c *EvmTxStore_GetTxInProgress_Call) Return(etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], err error) *EvmTxStore_GetTxInProgress_Call

func (*EvmTxStore_GetTxInProgress_Call) Run ¶

func (_c *EvmTxStore_GetTxInProgress_Call) Run(run func(ctx context.Context, fromAddress common.Address)) *EvmTxStore_GetTxInProgress_Call

func (*EvmTxStore_GetTxInProgress_Call) RunAndReturn ¶

func (_c *EvmTxStore_GetTxInProgress_Call) RunAndReturn(run func(context.Context, common.Address) (*types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], error)) *EvmTxStore_GetTxInProgress_Call

func (*EvmTxStore_HasInProgressTransaction_Call) Return ¶

func (_c *EvmTxStore_HasInProgressTransaction_Call) Return(exists bool, err error) *EvmTxStore_HasInProgressTransaction_Call

func (*EvmTxStore_HasInProgressTransaction_Call) Run ¶

func (_c *EvmTxStore_HasInProgressTransaction_Call) Run(run func(ctx context.Context, account common.Address, chainID *big.Int)) *EvmTxStore_HasInProgressTransaction_Call

func (*EvmTxStore_HasInProgressTransaction_Call) RunAndReturn ¶

func (_c *EvmTxStore_HasInProgressTransaction_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (bool, error)) *EvmTxStore_HasInProgressTransaction_Call

func (*EvmTxStore_LoadTxAttempts_Call) Return ¶

func (_c *EvmTxStore_LoadTxAttempts_Call) Return(_a0 error) *EvmTxStore_LoadTxAttempts_Call

func (*EvmTxStore_LoadTxAttempts_Call) Run ¶

func (_c *EvmTxStore_LoadTxAttempts_Call) Run(run func(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee])) *EvmTxStore_LoadTxAttempts_Call

func (*EvmTxStore_LoadTxAttempts_Call) RunAndReturn ¶

func (_c *EvmTxStore_LoadTxAttempts_Call) RunAndReturn(run func(context.Context, *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error) *EvmTxStore_LoadTxAttempts_Call

func (*EvmTxStore_PreloadTxes_Call) Return ¶

func (_c *EvmTxStore_PreloadTxes_Call) Return(_a0 error) *EvmTxStore_PreloadTxes_Call

func (*EvmTxStore_PreloadTxes_Call) Run ¶

func (_c *EvmTxStore_PreloadTxes_Call) Run(run func(ctx context.Context, attempts []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee])) *EvmTxStore_PreloadTxes_Call

func (*EvmTxStore_PreloadTxes_Call) RunAndReturn ¶

func (_c *EvmTxStore_PreloadTxes_Call) RunAndReturn(run func(context.Context, []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error) *EvmTxStore_PreloadTxes_Call

func (*EvmTxStore_PruneUnstartedTxQueue_Call) Return ¶

func (_c *EvmTxStore_PruneUnstartedTxQueue_Call) Return(ids []int64, err error) *EvmTxStore_PruneUnstartedTxQueue_Call

func (*EvmTxStore_PruneUnstartedTxQueue_Call) Run ¶

func (_c *EvmTxStore_PruneUnstartedTxQueue_Call) Run(run func(ctx context.Context, queueSize uint32, subject uuid.UUID)) *EvmTxStore_PruneUnstartedTxQueue_Call

func (*EvmTxStore_PruneUnstartedTxQueue_Call) RunAndReturn ¶

func (_c *EvmTxStore_PruneUnstartedTxQueue_Call) RunAndReturn(run func(context.Context, uint32, uuid.UUID) ([]int64, error)) *EvmTxStore_PruneUnstartedTxQueue_Call

func (*EvmTxStore_ReapTxHistory_Call) Return ¶

func (_c *EvmTxStore_ReapTxHistory_Call) Return(_a0 error) *EvmTxStore_ReapTxHistory_Call

func (*EvmTxStore_ReapTxHistory_Call) Run ¶

func (_c *EvmTxStore_ReapTxHistory_Call) Run(run func(ctx context.Context, timeThreshold time.Time, chainID *big.Int)) *EvmTxStore_ReapTxHistory_Call

func (*EvmTxStore_ReapTxHistory_Call) RunAndReturn ¶

func (_c *EvmTxStore_ReapTxHistory_Call) RunAndReturn(run func(context.Context, time.Time, *big.Int) error) *EvmTxStore_ReapTxHistory_Call

func (*EvmTxStore_SaveConfirmedAttempt_Call) Return ¶

func (_c *EvmTxStore_SaveConfirmedAttempt_Call) Return(_a0 error) *EvmTxStore_SaveConfirmedAttempt_Call

func (*EvmTxStore_SaveConfirmedAttempt_Call) Run ¶

func (_c *EvmTxStore_SaveConfirmedAttempt_Call) Run(run func(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], broadcastAt time.Time)) *EvmTxStore_SaveConfirmedAttempt_Call

func (*EvmTxStore_SaveConfirmedAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_SaveConfirmedAttempt_Call) RunAndReturn(run func(context.Context, time.Duration, *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], time.Time) error) *EvmTxStore_SaveConfirmedAttempt_Call

func (*EvmTxStore_SaveFetchedReceipts_Call) Return ¶

func (_c *EvmTxStore_SaveFetchedReceipts_Call) Return(err error) *EvmTxStore_SaveFetchedReceipts_Call

func (*EvmTxStore_SaveFetchedReceipts_Call) Run ¶

func (_c *EvmTxStore_SaveFetchedReceipts_Call) Run(run func(ctx context.Context, r []*pkgtypes.Receipt)) *EvmTxStore_SaveFetchedReceipts_Call

func (*EvmTxStore_SaveFetchedReceipts_Call) RunAndReturn ¶

func (_c *EvmTxStore_SaveFetchedReceipts_Call) RunAndReturn(run func(context.Context, []*pkgtypes.Receipt) error) *EvmTxStore_SaveFetchedReceipts_Call

func (*EvmTxStore_SaveInProgressAttempt_Call) Return ¶

func (_c *EvmTxStore_SaveInProgressAttempt_Call) Return(_a0 error) *EvmTxStore_SaveInProgressAttempt_Call

func (*EvmTxStore_SaveInProgressAttempt_Call) Run ¶

func (_c *EvmTxStore_SaveInProgressAttempt_Call) Run(run func(ctx context.Context, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee])) *EvmTxStore_SaveInProgressAttempt_Call

func (*EvmTxStore_SaveInProgressAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_SaveInProgressAttempt_Call) RunAndReturn(run func(context.Context, *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error) *EvmTxStore_SaveInProgressAttempt_Call

func (*EvmTxStore_SaveInsufficientFundsAttempt_Call) Return ¶

func (_c *EvmTxStore_SaveInsufficientFundsAttempt_Call) Return(_a0 error) *EvmTxStore_SaveInsufficientFundsAttempt_Call

func (*EvmTxStore_SaveInsufficientFundsAttempt_Call) Run ¶

func (_c *EvmTxStore_SaveInsufficientFundsAttempt_Call) Run(run func(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], broadcastAt time.Time)) *EvmTxStore_SaveInsufficientFundsAttempt_Call

func (*EvmTxStore_SaveInsufficientFundsAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_SaveInsufficientFundsAttempt_Call) RunAndReturn(run func(context.Context, time.Duration, *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], time.Time) error) *EvmTxStore_SaveInsufficientFundsAttempt_Call

func (*EvmTxStore_SaveReplacementInProgressAttempt_Call) Return ¶

func (_c *EvmTxStore_SaveReplacementInProgressAttempt_Call) Return(_a0 error) *EvmTxStore_SaveReplacementInProgressAttempt_Call

func (*EvmTxStore_SaveReplacementInProgressAttempt_Call) Run ¶

func (_c *EvmTxStore_SaveReplacementInProgressAttempt_Call) Run(run func(ctx context.Context, oldAttempt types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], replacementAttempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee])) *EvmTxStore_SaveReplacementInProgressAttempt_Call

func (*EvmTxStore_SaveReplacementInProgressAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_SaveReplacementInProgressAttempt_Call) RunAndReturn(run func(context.Context, types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error) *EvmTxStore_SaveReplacementInProgressAttempt_Call

func (*EvmTxStore_SaveSentAttempt_Call) Return ¶

func (_c *EvmTxStore_SaveSentAttempt_Call) Return(_a0 error) *EvmTxStore_SaveSentAttempt_Call

func (*EvmTxStore_SaveSentAttempt_Call) Run ¶

func (_c *EvmTxStore_SaveSentAttempt_Call) Run(run func(ctx context.Context, timeout time.Duration, attempt *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], broadcastAt time.Time)) *EvmTxStore_SaveSentAttempt_Call

func (*EvmTxStore_SaveSentAttempt_Call) RunAndReturn ¶

func (_c *EvmTxStore_SaveSentAttempt_Call) RunAndReturn(run func(context.Context, time.Duration, *types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], time.Time) error) *EvmTxStore_SaveSentAttempt_Call

func (*EvmTxStore_SetBroadcastBeforeBlockNum_Call) Return ¶

func (_c *EvmTxStore_SetBroadcastBeforeBlockNum_Call) Return(_a0 error) *EvmTxStore_SetBroadcastBeforeBlockNum_Call

func (*EvmTxStore_SetBroadcastBeforeBlockNum_Call) Run ¶

func (_c *EvmTxStore_SetBroadcastBeforeBlockNum_Call) Run(run func(ctx context.Context, blockNum int64, chainID *big.Int)) *EvmTxStore_SetBroadcastBeforeBlockNum_Call

func (*EvmTxStore_SetBroadcastBeforeBlockNum_Call) RunAndReturn ¶

func (_c *EvmTxStore_SetBroadcastBeforeBlockNum_Call) RunAndReturn(run func(context.Context, int64, *big.Int) error) *EvmTxStore_SetBroadcastBeforeBlockNum_Call

func (*EvmTxStore_TransactionsWithAttempts_Call) Return ¶

func (_c *EvmTxStore_TransactionsWithAttempts_Call) Return(_a0 []types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 int, _a2 error) *EvmTxStore_TransactionsWithAttempts_Call

func (*EvmTxStore_TransactionsWithAttempts_Call) Run ¶

func (_c *EvmTxStore_TransactionsWithAttempts_Call) Run(run func(ctx context.Context, offset int, limit int)) *EvmTxStore_TransactionsWithAttempts_Call

func (*EvmTxStore_TransactionsWithAttempts_Call) RunAndReturn ¶

func (_c *EvmTxStore_TransactionsWithAttempts_Call) RunAndReturn(run func(context.Context, int, int) ([]types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], int, error)) *EvmTxStore_TransactionsWithAttempts_Call

func (*EvmTxStore_Transactions_Call) Return ¶

func (_c *EvmTxStore_Transactions_Call) Return(_a0 []types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 int, _a2 error) *EvmTxStore_Transactions_Call

func (*EvmTxStore_Transactions_Call) Run ¶

func (_c *EvmTxStore_Transactions_Call) Run(run func(ctx context.Context, offset int, limit int)) *EvmTxStore_Transactions_Call

func (*EvmTxStore_Transactions_Call) RunAndReturn ¶

func (_c *EvmTxStore_Transactions_Call) RunAndReturn(run func(context.Context, int, int) ([]types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], int, error)) *EvmTxStore_Transactions_Call

func (*EvmTxStore_TxAttempts_Call) Return ¶

func (_c *EvmTxStore_TxAttempts_Call) Return(_a0 []types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], _a1 int, _a2 error) *EvmTxStore_TxAttempts_Call

func (*EvmTxStore_TxAttempts_Call) Run ¶

func (_c *EvmTxStore_TxAttempts_Call) Run(run func(ctx context.Context, offset int, limit int)) *EvmTxStore_TxAttempts_Call

func (*EvmTxStore_TxAttempts_Call) RunAndReturn ¶

func (_c *EvmTxStore_TxAttempts_Call) RunAndReturn(run func(context.Context, int, int) ([]types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], int, error)) *EvmTxStore_TxAttempts_Call

func (*EvmTxStore_UpdateBroadcastAts_Call) Return ¶

func (_c *EvmTxStore_UpdateBroadcastAts_Call) Return(_a0 error) *EvmTxStore_UpdateBroadcastAts_Call

func (*EvmTxStore_UpdateBroadcastAts_Call) Run ¶

func (_c *EvmTxStore_UpdateBroadcastAts_Call) Run(run func(ctx context.Context, now time.Time, etxIDs []int64)) *EvmTxStore_UpdateBroadcastAts_Call

func (*EvmTxStore_UpdateBroadcastAts_Call) RunAndReturn ¶

func (_c *EvmTxStore_UpdateBroadcastAts_Call) RunAndReturn(run func(context.Context, time.Time, []int64) error) *EvmTxStore_UpdateBroadcastAts_Call

func (*EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call) Return ¶

func (_c *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call) Return(_a0 error) *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call

func (*EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call) Run ¶

func (_c *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call) Run(run func(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], attempt types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], NewAttemptState types.TxAttemptState)) *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call

func (*EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call) RunAndReturn ¶

func (_c *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call) RunAndReturn(run func(context.Context, *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], types.TxAttempt[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee], types.TxAttemptState) error) *EvmTxStore_UpdateTxAttemptInProgressToBroadcast_Call

func (*EvmTxStore_UpdateTxCallbackCompleted_Call) Return ¶

func (_c *EvmTxStore_UpdateTxCallbackCompleted_Call) Return(_a0 error) *EvmTxStore_UpdateTxCallbackCompleted_Call

func (*EvmTxStore_UpdateTxCallbackCompleted_Call) Run ¶

func (_c *EvmTxStore_UpdateTxCallbackCompleted_Call) Run(run func(ctx context.Context, pipelineTaskRunRid uuid.UUID, chainID *big.Int)) *EvmTxStore_UpdateTxCallbackCompleted_Call

func (*EvmTxStore_UpdateTxCallbackCompleted_Call) RunAndReturn ¶

func (_c *EvmTxStore_UpdateTxCallbackCompleted_Call) RunAndReturn(run func(context.Context, uuid.UUID, *big.Int) error) *EvmTxStore_UpdateTxCallbackCompleted_Call

func (*EvmTxStore_UpdateTxConfirmed_Call) Return ¶

func (_c *EvmTxStore_UpdateTxConfirmed_Call) Return(_a0 error) *EvmTxStore_UpdateTxConfirmed_Call

func (*EvmTxStore_UpdateTxConfirmed_Call) Run ¶

func (_c *EvmTxStore_UpdateTxConfirmed_Call) Run(run func(ctx context.Context, etxIDs []int64)) *EvmTxStore_UpdateTxConfirmed_Call

func (*EvmTxStore_UpdateTxConfirmed_Call) RunAndReturn ¶

func (_c *EvmTxStore_UpdateTxConfirmed_Call) RunAndReturn(run func(context.Context, []int64) error) *EvmTxStore_UpdateTxConfirmed_Call

func (*EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call) Return ¶

func (_c *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call) Return(_a0 error) *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call

func (*EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call) Run ¶

func (_c *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call) Run(run func(ctx context.Context, etx *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee])) *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call

func (*EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call) RunAndReturn ¶

func (_c *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call) RunAndReturn(run func(context.Context, *types.Tx[*big.Int, common.Address, common.Hash, common.Hash, pkgtypes.Nonce, gas.EvmFee]) error) *EvmTxStore_UpdateTxFatalErrorAndDeleteAttempts_Call

func (*EvmTxStore_UpdateTxFatalError_Call) Return ¶

func (_c *EvmTxStore_UpdateTxFatalError_Call) Return(_a0 error) *EvmTxStore_UpdateTxFatalError_Call

func (*EvmTxStore_UpdateTxFatalError_Call) Run ¶

func (_c *EvmTxStore_UpdateTxFatalError_Call) Run(run func(ctx context.Context, etxIDs []int64, errMsg string)) *EvmTxStore_UpdateTxFatalError_Call

func (*EvmTxStore_UpdateTxFatalError_Call) RunAndReturn ¶

func (_c *EvmTxStore_UpdateTxFatalError_Call) RunAndReturn(run func(context.Context, []int64, string) error) *EvmTxStore_UpdateTxFatalError_Call

func (*EvmTxStore_UpdateTxStatesToFinalizedUsingTxHashes_Call) Return ¶

func (_c *EvmTxStore_UpdateTxStatesToFinalizedUsingTxHashes_Call) Return(_a0 error) *EvmTxStore_UpdateTxStatesToFinalizedUsingTxHashes_Call