relayer.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./relayer/proto (interfaces: RelayerClient)
//
// Generated by this command:
//
//	mockgen -destination lib/mock/relayer.mock.go -package mock -mock_names RelayerClient=Relayer ./relayer/proto RelayerClient
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	proto "github.com/0xsequence/go-sequence/relayer/proto"
	gomock "go.uber.org/mock/gomock"
)

// Relayer is a mock of RelayerClient interface.
type Relayer struct {
	ctrl     *gomock.Controller
	recorder *RelayerMockRecorder
	isgomock struct{}
}

// RelayerMockRecorder is the mock recorder for Relayer.
type RelayerMockRecorder struct {
	mock *Relayer
}

// NewRelayer creates a new mock instance.
func NewRelayer(ctrl *gomock.Controller) *Relayer {
	mock := &Relayer{ctrl: ctrl}
	mock.recorder = &RelayerMockRecorder{mock}
	return mock
}

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

// AddEcosystemGasSponsor mocks base method.
func (m *Relayer) AddEcosystemGasSponsor(ctx context.Context, ecosystemId uint64, address string, name *string, active *bool) (bool, *proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddEcosystemGasSponsor", ctx, ecosystemId, address, name, active)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddEcosystemGasSponsor indicates an expected call of AddEcosystemGasSponsor.
func (mr *RelayerMockRecorder) AddEcosystemGasSponsor(ctx, ecosystemId, address, name, active any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEcosystemGasSponsor", reflect.TypeOf((*Relayer)(nil).AddEcosystemGasSponsor), ctx, ecosystemId, address, name, active)
}

// AddGasSponsor mocks base method.
func (m *Relayer) AddGasSponsor(ctx context.Context, projectId uint64, address string, name *string, active *bool) (bool, *proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddGasSponsor", ctx, projectId, address, name, active)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddGasSponsor indicates an expected call of AddGasSponsor.
func (mr *RelayerMockRecorder) AddGasSponsor(ctx, projectId, address, name, active any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGasSponsor", reflect.TypeOf((*Relayer)(nil).AddGasSponsor), ctx, projectId, address, name, active)
}

// AddGasTank mocks base method.
func (m *Relayer) AddGasTank(ctx context.Context, name string, feeMarkupFactor float64, unlimited *bool) (bool, *proto.GasTank, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddGasTank", ctx, name, feeMarkupFactor, unlimited)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasTank)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddGasTank indicates an expected call of AddGasTank.
func (mr *RelayerMockRecorder) AddGasTank(ctx, name, feeMarkupFactor, unlimited any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGasTank", reflect.TypeOf((*Relayer)(nil).AddGasTank), ctx, name, feeMarkupFactor, unlimited)
}

// AddressGasSponsors mocks base method.
func (m *Relayer) AddressGasSponsors(ctx context.Context, address string, page *proto.Page) (*proto.Page, []*proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddressGasSponsors", ctx, address, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddressGasSponsors indicates an expected call of AddressGasSponsors.
func (mr *RelayerMockRecorder) AddressGasSponsors(ctx, address, page any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddressGasSponsors", reflect.TypeOf((*Relayer)(nil).AddressGasSponsors), ctx, address, page)
}

// AdjustGasTankBalance mocks base method.
func (m *Relayer) AdjustGasTankBalance(ctx context.Context, id, nonce uint64, amount float64) (bool, *proto.GasTankBalanceAdjustment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AdjustGasTankBalance", ctx, id, nonce, amount)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasTankBalanceAdjustment)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AdjustGasTankBalance indicates an expected call of AdjustGasTankBalance.
func (mr *RelayerMockRecorder) AdjustGasTankBalance(ctx, id, nonce, amount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdjustGasTankBalance", reflect.TypeOf((*Relayer)(nil).AdjustGasTankBalance), ctx, id, nonce, amount)
}

// AdjustProjectBalance mocks base method.
func (m *Relayer) AdjustProjectBalance(ctx context.Context, projectId uint64, amount float64, identifier string) (float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AdjustProjectBalance", ctx, projectId, amount, identifier)
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AdjustProjectBalance indicates an expected call of AdjustProjectBalance.
func (mr *RelayerMockRecorder) AdjustProjectBalance(ctx, projectId, amount, identifier any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdjustProjectBalance", reflect.TypeOf((*Relayer)(nil).AdjustProjectBalance), ctx, projectId, amount, identifier)
}

// FeeOptions mocks base method.
func (m *Relayer) FeeOptions(ctx context.Context, wallet, to, data string, simulate *bool) ([]*proto.FeeOption, bool, *string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FeeOptions", ctx, wallet, to, data, simulate)
	ret0, _ := ret[0].([]*proto.FeeOption)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(*string)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// FeeOptions indicates an expected call of FeeOptions.
func (mr *RelayerMockRecorder) FeeOptions(ctx, wallet, to, data, simulate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeOptions", reflect.TypeOf((*Relayer)(nil).FeeOptions), ctx, wallet, to, data, simulate)
}

// FeeOptionsWithBridgeGas mocks base method.
func (m *Relayer) FeeOptionsWithBridgeGas(ctx context.Context, wallet, to, data string, simulate *bool, bridgeGas string) ([]*proto.FeeOption, bool, *string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FeeOptionsWithBridgeGas", ctx, wallet, to, data, simulate, bridgeGas)
	ret0, _ := ret[0].([]*proto.FeeOption)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(*string)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// FeeOptionsWithBridgeGas indicates an expected call of FeeOptionsWithBridgeGas.
func (mr *RelayerMockRecorder) FeeOptionsWithBridgeGas(ctx, wallet, to, data, simulate, bridgeGas any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeOptionsWithBridgeGas", reflect.TypeOf((*Relayer)(nil).FeeOptionsWithBridgeGas), ctx, wallet, to, data, simulate, bridgeGas)
}

// FeeTokens mocks base method.
func (m *Relayer) FeeTokens(ctx context.Context) (bool, []*proto.FeeToken, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FeeTokens", ctx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].([]*proto.FeeToken)
	ret2, _ := ret[2].(string)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

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

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

// GetEcosystemGasSponsor mocks base method.
func (m *Relayer) GetEcosystemGasSponsor(ctx context.Context, ecosystemId, id uint64) (*proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEcosystemGasSponsor", ctx, ecosystemId, id)
	ret0, _ := ret[0].(*proto.GasSponsor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEcosystemGasSponsor indicates an expected call of GetEcosystemGasSponsor.
func (mr *RelayerMockRecorder) GetEcosystemGasSponsor(ctx, ecosystemId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEcosystemGasSponsor", reflect.TypeOf((*Relayer)(nil).GetEcosystemGasSponsor), ctx, ecosystemId, id)
}

// GetGasSponsor mocks base method.
func (m *Relayer) GetGasSponsor(ctx context.Context, projectId, id uint64) (*proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGasSponsor", ctx, projectId, id)
	ret0, _ := ret[0].(*proto.GasSponsor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGasSponsor indicates an expected call of GetGasSponsor.
func (mr *RelayerMockRecorder) GetGasSponsor(ctx, projectId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGasSponsor", reflect.TypeOf((*Relayer)(nil).GetGasSponsor), ctx, projectId, id)
}

// GetGasTank mocks base method.
func (m *Relayer) GetGasTank(ctx context.Context, id uint64) (*proto.GasTank, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGasTank", ctx, id)
	ret0, _ := ret[0].(*proto.GasTank)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGasTankBalanceAdjustment mocks base method.
func (m *Relayer) GetGasTankBalanceAdjustment(ctx context.Context, id, nonce uint64) (*proto.GasTankBalanceAdjustment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGasTankBalanceAdjustment", ctx, id, nonce)
	ret0, _ := ret[0].(*proto.GasTankBalanceAdjustment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGasTankBalanceAdjustment indicates an expected call of GetGasTankBalanceAdjustment.
func (mr *RelayerMockRecorder) GetGasTankBalanceAdjustment(ctx, id, nonce any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGasTankBalanceAdjustment", reflect.TypeOf((*Relayer)(nil).GetGasTankBalanceAdjustment), ctx, id, nonce)
}

// GetMetaTransactions mocks base method.
func (m *Relayer) GetMetaTransactions(ctx context.Context, projectId uint64, page *proto.Page) (*proto.Page, []*proto.MetaTxnLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaTransactions", ctx, projectId, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.MetaTxnLog)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMetaTransactions indicates an expected call of GetMetaTransactions.
func (mr *RelayerMockRecorder) GetMetaTransactions(ctx, projectId, page any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaTransactions", reflect.TypeOf((*Relayer)(nil).GetMetaTransactions), ctx, projectId, page)
}

// GetMetaTxnNetworkFeeOptions mocks base method.
func (m *Relayer) GetMetaTxnNetworkFeeOptions(ctx context.Context, walletConfig any, payload string) ([]*proto.FeeOption, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaTxnNetworkFeeOptions", ctx, walletConfig, payload)
	ret0, _ := ret[0].([]*proto.FeeOption)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetaTxnNetworkFeeOptions indicates an expected call of GetMetaTxnNetworkFeeOptions.
func (mr *RelayerMockRecorder) GetMetaTxnNetworkFeeOptions(ctx, walletConfig, payload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaTxnNetworkFeeOptions", reflect.TypeOf((*Relayer)(nil).GetMetaTxnNetworkFeeOptions), ctx, walletConfig, payload)
}

// GetMetaTxnNonce mocks base method.
func (m *Relayer) GetMetaTxnNonce(ctx context.Context, walletContractAddress string, space *string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaTxnNonce", ctx, walletContractAddress, space)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetaTxnNonce indicates an expected call of GetMetaTxnNonce.
func (mr *RelayerMockRecorder) GetMetaTxnNonce(ctx, walletContractAddress, space any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaTxnNonce", reflect.TypeOf((*Relayer)(nil).GetMetaTxnNonce), ctx, walletContractAddress, space)
}

// GetMetaTxnReceipt mocks base method.
func (m *Relayer) GetMetaTxnReceipt(ctx context.Context, metaTxID string) (*proto.MetaTxnReceipt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaTxnReceipt", ctx, metaTxID)
	ret0, _ := ret[0].(*proto.MetaTxnReceipt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProjectBalance mocks base method.
func (m *Relayer) GetProjectBalance(ctx context.Context, projectId uint64) (float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectBalance", ctx, projectId)
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetTransactionCost mocks base method.
func (m *Relayer) GetTransactionCost(ctx context.Context, projectId uint64, from, to time.Time) (float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransactionCost", ctx, projectId, from, to)
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransactionCost indicates an expected call of GetTransactionCost.
func (mr *RelayerMockRecorder) GetTransactionCost(ctx, projectId, from, to any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionCost", reflect.TypeOf((*Relayer)(nil).GetTransactionCost), ctx, projectId, from, to)
}

// ListEcosystemGasSponsors mocks base method.
func (m *Relayer) ListEcosystemGasSponsors(ctx context.Context, ecosystemId uint64, page *proto.Page) (*proto.Page, []*proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEcosystemGasSponsors", ctx, ecosystemId, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListEcosystemGasSponsors indicates an expected call of ListEcosystemGasSponsors.
func (mr *RelayerMockRecorder) ListEcosystemGasSponsors(ctx, ecosystemId, page any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEcosystemGasSponsors", reflect.TypeOf((*Relayer)(nil).ListEcosystemGasSponsors), ctx, ecosystemId, page)
}

// ListGasSponsors mocks base method.
func (m *Relayer) ListGasSponsors(ctx context.Context, projectId uint64, page *proto.Page) (*proto.Page, []*proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGasSponsors", ctx, projectId, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListGasSponsors indicates an expected call of ListGasSponsors.
func (mr *RelayerMockRecorder) ListGasSponsors(ctx, projectId, page any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGasSponsors", reflect.TypeOf((*Relayer)(nil).ListGasSponsors), ctx, projectId, page)
}

// ListGasTankBalanceAdjustments mocks base method.
func (m *Relayer) ListGasTankBalanceAdjustments(ctx context.Context, id uint64, page *proto.Page) (*proto.Page, []*proto.GasTankBalanceAdjustment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGasTankBalanceAdjustments", ctx, id, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.GasTankBalanceAdjustment)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListGasTankBalanceAdjustments indicates an expected call of ListGasTankBalanceAdjustments.
func (mr *RelayerMockRecorder) ListGasTankBalanceAdjustments(ctx, id, page any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGasTankBalanceAdjustments", reflect.TypeOf((*Relayer)(nil).ListGasTankBalanceAdjustments), ctx, id, page)
}

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

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

// PendingTransactions mocks base method.
func (m *Relayer) PendingTransactions(ctx context.Context, page *proto.Page) (*proto.Page, []*proto.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingTransactions", ctx, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.Transaction)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// RemoveEcosystemGasSponsor mocks base method.
func (m *Relayer) RemoveEcosystemGasSponsor(ctx context.Context, ecosystemId, id uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveEcosystemGasSponsor", ctx, ecosystemId, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveEcosystemGasSponsor indicates an expected call of RemoveEcosystemGasSponsor.
func (mr *RelayerMockRecorder) RemoveEcosystemGasSponsor(ctx, ecosystemId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveEcosystemGasSponsor", reflect.TypeOf((*Relayer)(nil).RemoveEcosystemGasSponsor), ctx, ecosystemId, id)
}

// RemoveGasSponsor mocks base method.
func (m *Relayer) RemoveGasSponsor(ctx context.Context, projectId, id uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveGasSponsor", ctx, projectId, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveGasSponsor indicates an expected call of RemoveGasSponsor.
func (mr *RelayerMockRecorder) RemoveGasSponsor(ctx, projectId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveGasSponsor", reflect.TypeOf((*Relayer)(nil).RemoveGasSponsor), ctx, projectId, id)
}

// ResetSender mocks base method.
func (m *Relayer) ResetSender(ctx context.Context, sender int) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetSender", ctx, sender)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SendMetaTxn mocks base method.
func (m *Relayer) SendMetaTxn(ctx context.Context, call *proto.MetaTxn, quote *string, projectID *uint64, preconditions []*proto.TransactionPrecondition) (bool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMetaTxn", ctx, call, quote, projectID, preconditions)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SendMetaTxn indicates an expected call of SendMetaTxn.
func (mr *RelayerMockRecorder) SendMetaTxn(ctx, call, quote, projectID, preconditions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMetaTxn", reflect.TypeOf((*Relayer)(nil).SendMetaTxn), ctx, call, quote, projectID, preconditions)
}

// SendMetaTxnWithBridgeGas mocks base method.
func (m *Relayer) SendMetaTxnWithBridgeGas(ctx context.Context, call *proto.MetaTxn, quote *string, projectID *uint64, bridgeGas string, preconditions []*proto.TransactionPrecondition) (bool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMetaTxnWithBridgeGas", ctx, call, quote, projectID, bridgeGas, preconditions)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SendMetaTxnWithBridgeGas indicates an expected call of SendMetaTxnWithBridgeGas.
func (mr *RelayerMockRecorder) SendMetaTxnWithBridgeGas(ctx, call, quote, projectID, bridgeGas, preconditions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMetaTxnWithBridgeGas", reflect.TypeOf((*Relayer)(nil).SendMetaTxnWithBridgeGas), ctx, call, quote, projectID, bridgeGas, preconditions)
}

// SentTransactions mocks base method.
func (m *Relayer) SentTransactions(ctx context.Context, filter *proto.SentTransactionsFilter, page *proto.Page) (*proto.Page, []*proto.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SentTransactions", ctx, filter, page)
	ret0, _ := ret[0].(*proto.Page)
	ret1, _ := ret[1].([]*proto.Transaction)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SentTransactions indicates an expected call of SentTransactions.
func (mr *RelayerMockRecorder) SentTransactions(ctx, filter, page any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentTransactions", reflect.TypeOf((*Relayer)(nil).SentTransactions), ctx, filter, page)
}

// Simulate mocks base method.
func (m *Relayer) Simulate(ctx context.Context, wallet, transactions string) ([]*proto.SimulateResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Simulate", ctx, wallet, transactions)
	ret0, _ := ret[0].([]*proto.SimulateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Simulate indicates an expected call of Simulate.
func (mr *RelayerMockRecorder) Simulate(ctx, wallet, transactions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Simulate", reflect.TypeOf((*Relayer)(nil).Simulate), ctx, wallet, transactions)
}

// SimulateV3 mocks base method.
func (m *Relayer) SimulateV3(ctx context.Context, wallet, calls string) ([]*proto.SimulateV3Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SimulateV3", ctx, wallet, calls)
	ret0, _ := ret[0].([]*proto.SimulateV3Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SimulateV3 indicates an expected call of SimulateV3.
func (mr *RelayerMockRecorder) SimulateV3(ctx, wallet, calls any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulateV3", reflect.TypeOf((*Relayer)(nil).SimulateV3), ctx, wallet, calls)
}

// StartSender mocks base method.
func (m *Relayer) StartSender(ctx context.Context, sender int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartSender", ctx, sender)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StopSender mocks base method.
func (m *Relayer) StopSender(ctx context.Context, sender int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopSender", ctx, sender)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateEcosystemGasSponsor mocks base method.
func (m *Relayer) UpdateEcosystemGasSponsor(ctx context.Context, ecosystemId, id uint64, name *string, active *bool) (bool, *proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEcosystemGasSponsor", ctx, ecosystemId, id, name, active)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateEcosystemGasSponsor indicates an expected call of UpdateEcosystemGasSponsor.
func (mr *RelayerMockRecorder) UpdateEcosystemGasSponsor(ctx, ecosystemId, id, name, active any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEcosystemGasSponsor", reflect.TypeOf((*Relayer)(nil).UpdateEcosystemGasSponsor), ctx, ecosystemId, id, name, active)
}

// UpdateGasSponsor mocks base method.
func (m *Relayer) UpdateGasSponsor(ctx context.Context, projectId, id uint64, name *string, active *bool) (bool, *proto.GasSponsor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGasSponsor", ctx, projectId, id, name, active)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasSponsor)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateGasSponsor indicates an expected call of UpdateGasSponsor.
func (mr *RelayerMockRecorder) UpdateGasSponsor(ctx, projectId, id, name, active any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGasSponsor", reflect.TypeOf((*Relayer)(nil).UpdateGasSponsor), ctx, projectId, id, name, active)
}

// UpdateGasTank mocks base method.
func (m *Relayer) UpdateGasTank(ctx context.Context, id uint64, name *string, feeMarkupFactor *float64, unlimited *bool) (bool, *proto.GasTank, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGasTank", ctx, id, name, feeMarkupFactor, unlimited)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*proto.GasTank)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateGasTank indicates an expected call of UpdateGasTank.
func (mr *RelayerMockRecorder) UpdateGasTank(ctx, id, name, feeMarkupFactor, unlimited any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGasTank", reflect.TypeOf((*Relayer)(nil).UpdateGasTank), ctx, id, name, feeMarkupFactor, unlimited)
}

// UpdateMetaTxnGasLimits mocks base method.
func (m *Relayer) UpdateMetaTxnGasLimits(ctx context.Context, walletAddress string, walletConfig any, payload string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMetaTxnGasLimits", ctx, walletAddress, walletConfig, payload)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMetaTxnGasLimits indicates an expected call of UpdateMetaTxnGasLimits.
func (mr *RelayerMockRecorder) UpdateMetaTxnGasLimits(ctx, walletAddress, walletConfig, payload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMetaTxnGasLimits", reflect.TypeOf((*Relayer)(nil).UpdateMetaTxnGasLimits), ctx, walletAddress, walletConfig, payload)
}

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

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