code.vegaprotocol.io/vega@v0.79.0/core/processor/mocks/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/processor (interfaces: TimeService,EpochService,DelegationEngine,ExecutionEngine,GovernanceEngine,Stats,Assets,ValidatorTopology,Notary,EvtForwarder,EvtForwarderHeartbeat,Witness,Banking,NetworkParameters,OraclesEngine,OracleAdaptors,Limits,StakeVerifier,StakingAccounts,ERC20MultiSigTopology,Checkpoint,Broker,SpamEngine,PoWEngine,SnapshotEngine,StateVarEngine,TeamsEngine,ReferralProgram,VolumeDiscountProgram,VolumeRebateProgram,BlockchainClient,ProtocolUpgradeService,EthCallEngine,BalanceChecker,PartiesEngine,TxCache,EthereumOracleVerifier,Codec)

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

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

	assets "code.vegaprotocol.io/vega/core/assets"
	abci "code.vegaprotocol.io/vega/core/blockchain/abci"
	broker "code.vegaprotocol.io/vega/core/broker"
	common "code.vegaprotocol.io/vega/core/datasource/common"
	ethcall "code.vegaprotocol.io/vega/core/datasource/external/ethcall"
	events "code.vegaprotocol.io/vega/core/events"
	common0 "code.vegaprotocol.io/vega/core/execution/common"
	governance "code.vegaprotocol.io/vega/core/governance"
	netparams "code.vegaprotocol.io/vega/core/netparams"
	pow "code.vegaprotocol.io/vega/core/pow"
	snapshot "code.vegaprotocol.io/vega/core/snapshot"
	types "code.vegaprotocol.io/vega/core/types"
	statevar "code.vegaprotocol.io/vega/core/types/statevar"
	crypto "code.vegaprotocol.io/vega/libs/crypto"
	num "code.vegaprotocol.io/vega/libs/num"
	vega "code.vegaprotocol.io/vega/protos/vega"
	v1 "code.vegaprotocol.io/vega/protos/vega/api/v1"
	v10 "code.vegaprotocol.io/vega/protos/vega/commands/v1"
	types0 "github.com/cometbft/cometbft/abci/types"
	types1 "github.com/cometbft/cometbft/types"
	gomock "github.com/golang/mock/gomock"
	decimal "github.com/shopspring/decimal"
)

// MockTimeService is a mock of TimeService interface.
type MockTimeService struct {
	ctrl     *gomock.Controller
	recorder *MockTimeServiceMockRecorder
}

// MockTimeServiceMockRecorder is the mock recorder for MockTimeService.
type MockTimeServiceMockRecorder struct {
	mock *MockTimeService
}

// NewMockTimeService creates a new mock instance.
func NewMockTimeService(ctrl *gomock.Controller) *MockTimeService {
	mock := &MockTimeService{ctrl: ctrl}
	mock.recorder = &MockTimeServiceMockRecorder{mock}
	return mock
}

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

// GetTimeLastBatch mocks base method.
func (m *MockTimeService) GetTimeLastBatch() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeLastBatch")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// GetTimeLastBatch indicates an expected call of GetTimeLastBatch.
func (mr *MockTimeServiceMockRecorder) GetTimeLastBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeLastBatch", reflect.TypeOf((*MockTimeService)(nil).GetTimeLastBatch))
}

// GetTimeNow mocks base method.
func (m *MockTimeService) GetTimeNow() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeNow")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// GetTimeNow indicates an expected call of GetTimeNow.
func (mr *MockTimeServiceMockRecorder) GetTimeNow() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeNow", reflect.TypeOf((*MockTimeService)(nil).GetTimeNow))
}

// NotifyOnTick mocks base method.
func (m *MockTimeService) NotifyOnTick(arg0 ...func(context.Context, time.Time)) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "NotifyOnTick", varargs...)
}

// NotifyOnTick indicates an expected call of NotifyOnTick.
func (mr *MockTimeServiceMockRecorder) NotifyOnTick(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyOnTick", reflect.TypeOf((*MockTimeService)(nil).NotifyOnTick), arg0...)
}

// SetTimeNow mocks base method.
func (m *MockTimeService) SetTimeNow(arg0 context.Context, arg1 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeNow", arg0, arg1)
}

// SetTimeNow indicates an expected call of SetTimeNow.
func (mr *MockTimeServiceMockRecorder) SetTimeNow(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeNow", reflect.TypeOf((*MockTimeService)(nil).SetTimeNow), arg0, arg1)
}

// MockEpochService is a mock of EpochService interface.
type MockEpochService struct {
	ctrl     *gomock.Controller
	recorder *MockEpochServiceMockRecorder
}

// MockEpochServiceMockRecorder is the mock recorder for MockEpochService.
type MockEpochServiceMockRecorder struct {
	mock *MockEpochService
}

// NewMockEpochService creates a new mock instance.
func NewMockEpochService(ctrl *gomock.Controller) *MockEpochService {
	mock := &MockEpochService{ctrl: ctrl}
	mock.recorder = &MockEpochServiceMockRecorder{mock}
	return mock
}

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

// NotifyOnEpoch mocks base method.
func (m *MockEpochService) NotifyOnEpoch(arg0, arg1 func(context.Context, types.Epoch)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyOnEpoch", arg0, arg1)
}

// NotifyOnEpoch indicates an expected call of NotifyOnEpoch.
func (mr *MockEpochServiceMockRecorder) NotifyOnEpoch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyOnEpoch", reflect.TypeOf((*MockEpochService)(nil).NotifyOnEpoch), arg0, arg1)
}

// OnBlockEnd mocks base method.
func (m *MockEpochService) OnBlockEnd(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnBlockEnd", arg0)
}

// OnBlockEnd indicates an expected call of OnBlockEnd.
func (mr *MockEpochServiceMockRecorder) OnBlockEnd(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnBlockEnd", reflect.TypeOf((*MockEpochService)(nil).OnBlockEnd), arg0)
}

// MockDelegationEngine is a mock of DelegationEngine interface.
type MockDelegationEngine struct {
	ctrl     *gomock.Controller
	recorder *MockDelegationEngineMockRecorder
}

// MockDelegationEngineMockRecorder is the mock recorder for MockDelegationEngine.
type MockDelegationEngineMockRecorder struct {
	mock *MockDelegationEngine
}

// NewMockDelegationEngine creates a new mock instance.
func NewMockDelegationEngine(ctrl *gomock.Controller) *MockDelegationEngine {
	mock := &MockDelegationEngine{ctrl: ctrl}
	mock.recorder = &MockDelegationEngineMockRecorder{mock}
	return mock
}

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

// Delegate mocks base method.
func (m *MockDelegationEngine) Delegate(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delegate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delegate indicates an expected call of Delegate.
func (mr *MockDelegationEngineMockRecorder) Delegate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delegate", reflect.TypeOf((*MockDelegationEngine)(nil).Delegate), arg0, arg1, arg2, arg3)
}

// Hash mocks base method.
func (m *MockDelegationEngine) Hash() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hash")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Hash indicates an expected call of Hash.
func (mr *MockDelegationEngineMockRecorder) Hash() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hash", reflect.TypeOf((*MockDelegationEngine)(nil).Hash))
}

// ProcessEpochDelegations mocks base method.
func (m *MockDelegationEngine) ProcessEpochDelegations(arg0 context.Context, arg1 types.Epoch) []*types.ValidatorData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessEpochDelegations", arg0, arg1)
	ret0, _ := ret[0].([]*types.ValidatorData)
	return ret0
}

// ProcessEpochDelegations indicates an expected call of ProcessEpochDelegations.
func (mr *MockDelegationEngineMockRecorder) ProcessEpochDelegations(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessEpochDelegations", reflect.TypeOf((*MockDelegationEngine)(nil).ProcessEpochDelegations), arg0, arg1)
}

// UndelegateAtEndOfEpoch mocks base method.
func (m *MockDelegationEngine) UndelegateAtEndOfEpoch(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UndelegateAtEndOfEpoch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// UndelegateAtEndOfEpoch indicates an expected call of UndelegateAtEndOfEpoch.
func (mr *MockDelegationEngineMockRecorder) UndelegateAtEndOfEpoch(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UndelegateAtEndOfEpoch", reflect.TypeOf((*MockDelegationEngine)(nil).UndelegateAtEndOfEpoch), arg0, arg1, arg2, arg3)
}

// UndelegateNow mocks base method.
func (m *MockDelegationEngine) UndelegateNow(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UndelegateNow", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// UndelegateNow indicates an expected call of UndelegateNow.
func (mr *MockDelegationEngineMockRecorder) UndelegateNow(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UndelegateNow", reflect.TypeOf((*MockDelegationEngine)(nil).UndelegateNow), arg0, arg1, arg2, arg3)
}

// MockExecutionEngine is a mock of ExecutionEngine interface.
type MockExecutionEngine struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionEngineMockRecorder
}

// MockExecutionEngineMockRecorder is the mock recorder for MockExecutionEngine.
type MockExecutionEngineMockRecorder struct {
	mock *MockExecutionEngine
}

// NewMockExecutionEngine creates a new mock instance.
func NewMockExecutionEngine(ctrl *gomock.Controller) *MockExecutionEngine {
	mock := &MockExecutionEngine{ctrl: ctrl}
	mock.recorder = &MockExecutionEngineMockRecorder{mock}
	return mock
}

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

// AmendAMM mocks base method.
func (m *MockExecutionEngine) AmendAMM(arg0 context.Context, arg1 *types.AmendAMM, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmendAMM", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AmendAMM indicates an expected call of AmendAMM.
func (mr *MockExecutionEngineMockRecorder) AmendAMM(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AmendAMM", reflect.TypeOf((*MockExecutionEngine)(nil).AmendAMM), arg0, arg1, arg2)
}

// AmendLiquidityProvision mocks base method.
func (m *MockExecutionEngine) AmendLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionAmendment, arg2, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmendLiquidityProvision", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// AmendLiquidityProvision indicates an expected call of AmendLiquidityProvision.
func (mr *MockExecutionEngineMockRecorder) AmendLiquidityProvision(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AmendLiquidityProvision", reflect.TypeOf((*MockExecutionEngine)(nil).AmendLiquidityProvision), arg0, arg1, arg2, arg3)
}

// AmendOrder mocks base method.
func (m *MockExecutionEngine) AmendOrder(arg0 context.Context, arg1 *types.OrderAmendment, arg2 string, arg3 common0.IDGenerator) (*types.OrderConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmendOrder", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*types.OrderConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AmendOrder indicates an expected call of AmendOrder.
func (mr *MockExecutionEngineMockRecorder) AmendOrder(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AmendOrder", reflect.TypeOf((*MockExecutionEngine)(nil).AmendOrder), arg0, arg1, arg2, arg3)
}

// BeginBlock mocks base method.
func (m *MockExecutionEngine) BeginBlock(arg0 context.Context, arg1 time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0, arg1)
}

// BeginBlock indicates an expected call of BeginBlock.
func (mr *MockExecutionEngineMockRecorder) BeginBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockExecutionEngine)(nil).BeginBlock), arg0, arg1)
}

// BlockEnd mocks base method.
func (m *MockExecutionEngine) BlockEnd(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BlockEnd", arg0)
}

// BlockEnd indicates an expected call of BlockEnd.
func (mr *MockExecutionEngineMockRecorder) BlockEnd(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockEnd", reflect.TypeOf((*MockExecutionEngine)(nil).BlockEnd), arg0)
}

// CancelAMM mocks base method.
func (m *MockExecutionEngine) CancelAMM(arg0 context.Context, arg1 *types.CancelAMM, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelAMM", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelAMM indicates an expected call of CancelAMM.
func (mr *MockExecutionEngineMockRecorder) CancelAMM(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelAMM", reflect.TypeOf((*MockExecutionEngine)(nil).CancelAMM), arg0, arg1, arg2)
}

// CancelLiquidityProvision mocks base method.
func (m *MockExecutionEngine) CancelLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionCancellation, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelLiquidityProvision", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelLiquidityProvision indicates an expected call of CancelLiquidityProvision.
func (mr *MockExecutionEngineMockRecorder) CancelLiquidityProvision(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelLiquidityProvision", reflect.TypeOf((*MockExecutionEngine)(nil).CancelLiquidityProvision), arg0, arg1, arg2)
}

// CancelOrder mocks base method.
func (m *MockExecutionEngine) CancelOrder(arg0 context.Context, arg1 *types.OrderCancellation, arg2 string, arg3 common0.IDGenerator) ([]*types.OrderCancellationConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelOrder", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.OrderCancellationConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelOrder indicates an expected call of CancelOrder.
func (mr *MockExecutionEngineMockRecorder) CancelOrder(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelOrder", reflect.TypeOf((*MockExecutionEngine)(nil).CancelOrder), arg0, arg1, arg2, arg3)
}

// CancelStopOrders mocks base method.
func (m *MockExecutionEngine) CancelStopOrders(arg0 context.Context, arg1 *types.StopOrdersCancellation, arg2 string, arg3 common0.IDGenerator) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelStopOrders", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelStopOrders indicates an expected call of CancelStopOrders.
func (mr *MockExecutionEngineMockRecorder) CancelStopOrders(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelStopOrders", reflect.TypeOf((*MockExecutionEngine)(nil).CancelStopOrders), arg0, arg1, arg2, arg3)
}

// CheckCanSubmitOrderOrLiquidityCommitment mocks base method.
func (m *MockExecutionEngine) CheckCanSubmitOrderOrLiquidityCommitment(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckCanSubmitOrderOrLiquidityCommitment", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckCanSubmitOrderOrLiquidityCommitment indicates an expected call of CheckCanSubmitOrderOrLiquidityCommitment.
func (mr *MockExecutionEngineMockRecorder) CheckCanSubmitOrderOrLiquidityCommitment(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckCanSubmitOrderOrLiquidityCommitment", reflect.TypeOf((*MockExecutionEngine)(nil).CheckCanSubmitOrderOrLiquidityCommitment), arg0, arg1)
}

// CheckOrderSubmissionForSpam mocks base method.
func (m *MockExecutionEngine) CheckOrderSubmissionForSpam(arg0 *types.OrderSubmission, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckOrderSubmissionForSpam", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckOrderSubmissionForSpam indicates an expected call of CheckOrderSubmissionForSpam.
func (mr *MockExecutionEngineMockRecorder) CheckOrderSubmissionForSpam(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckOrderSubmissionForSpam", reflect.TypeOf((*MockExecutionEngine)(nil).CheckOrderSubmissionForSpam), arg0, arg1)
}

// GetMarketCounters mocks base method.
func (m *MockExecutionEngine) GetMarketCounters() map[string]*types.MarketCounters {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMarketCounters")
	ret0, _ := ret[0].(map[string]*types.MarketCounters)
	return ret0
}

// GetMarketCounters indicates an expected call of GetMarketCounters.
func (mr *MockExecutionEngineMockRecorder) GetMarketCounters() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMarketCounters", reflect.TypeOf((*MockExecutionEngine)(nil).GetMarketCounters))
}

// Hash mocks base method.
func (m *MockExecutionEngine) Hash() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hash")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Hash indicates an expected call of Hash.
func (mr *MockExecutionEngineMockRecorder) Hash() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hash", reflect.TypeOf((*MockExecutionEngine)(nil).Hash))
}

// NewProtocolAutomatedPurchase mocks base method.
func (m *MockExecutionEngine) NewProtocolAutomatedPurchase(arg0 context.Context, arg1 string, arg2 *types.NewProtocolAutomatedPurchaseChanges) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewProtocolAutomatedPurchase", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// NewProtocolAutomatedPurchase indicates an expected call of NewProtocolAutomatedPurchase.
func (mr *MockExecutionEngineMockRecorder) NewProtocolAutomatedPurchase(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewProtocolAutomatedPurchase", reflect.TypeOf((*MockExecutionEngine)(nil).NewProtocolAutomatedPurchase), arg0, arg1, arg2)
}

// OnChainIDUpdate mocks base method.
func (m *MockExecutionEngine) OnChainIDUpdate(arg0 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnChainIDUpdate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnChainIDUpdate indicates an expected call of OnChainIDUpdate.
func (mr *MockExecutionEngineMockRecorder) OnChainIDUpdate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnChainIDUpdate", reflect.TypeOf((*MockExecutionEngine)(nil).OnChainIDUpdate), arg0)
}

// RejectMarket mocks base method.
func (m *MockExecutionEngine) RejectMarket(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectMarket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RejectMarket indicates an expected call of RejectMarket.
func (mr *MockExecutionEngineMockRecorder) RejectMarket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMarket", reflect.TypeOf((*MockExecutionEngine)(nil).RejectMarket), arg0, arg1)
}

// StartOpeningAuction mocks base method.
func (m *MockExecutionEngine) StartOpeningAuction(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartOpeningAuction", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartOpeningAuction indicates an expected call of StartOpeningAuction.
func (mr *MockExecutionEngineMockRecorder) StartOpeningAuction(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartOpeningAuction", reflect.TypeOf((*MockExecutionEngine)(nil).StartOpeningAuction), arg0, arg1)
}

// SubmitAMM mocks base method.
func (m *MockExecutionEngine) SubmitAMM(arg0 context.Context, arg1 *types.SubmitAMM, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitAMM", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubmitAMM indicates an expected call of SubmitAMM.
func (mr *MockExecutionEngineMockRecorder) SubmitAMM(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAMM", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitAMM), arg0, arg1, arg2)
}

// SubmitLiquidityProvision mocks base method.
func (m *MockExecutionEngine) SubmitLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionSubmission, arg2, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitLiquidityProvision", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubmitLiquidityProvision indicates an expected call of SubmitLiquidityProvision.
func (mr *MockExecutionEngineMockRecorder) SubmitLiquidityProvision(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitLiquidityProvision", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitLiquidityProvision), arg0, arg1, arg2, arg3)
}

// SubmitMarket mocks base method.
func (m *MockExecutionEngine) SubmitMarket(arg0 context.Context, arg1 *types.Market, arg2 string, arg3 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitMarket", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubmitMarket indicates an expected call of SubmitMarket.
func (mr *MockExecutionEngineMockRecorder) SubmitMarket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitMarket", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitMarket), arg0, arg1, arg2, arg3)
}

// SubmitOrder mocks base method.
func (m *MockExecutionEngine) SubmitOrder(arg0 context.Context, arg1 *types.OrderSubmission, arg2 string, arg3 common0.IDGenerator, arg4 string) (*types.OrderConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitOrder", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*types.OrderConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitOrder indicates an expected call of SubmitOrder.
func (mr *MockExecutionEngineMockRecorder) SubmitOrder(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitOrder", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitOrder), arg0, arg1, arg2, arg3, arg4)
}

// SubmitSpotMarket mocks base method.
func (m *MockExecutionEngine) SubmitSpotMarket(arg0 context.Context, arg1 *types.Market, arg2 string, arg3 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitSpotMarket", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubmitSpotMarket indicates an expected call of SubmitSpotMarket.
func (mr *MockExecutionEngineMockRecorder) SubmitSpotMarket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitSpotMarket", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitSpotMarket), arg0, arg1, arg2, arg3)
}

// SubmitStopOrders mocks base method.
func (m *MockExecutionEngine) SubmitStopOrders(arg0 context.Context, arg1 *types.StopOrdersSubmission, arg2 string, arg3 common0.IDGenerator, arg4, arg5 *string) (*types.OrderConfirmation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitStopOrders", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*types.OrderConfirmation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitStopOrders indicates an expected call of SubmitStopOrders.
func (mr *MockExecutionEngineMockRecorder) SubmitStopOrders(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitStopOrders", reflect.TypeOf((*MockExecutionEngine)(nil).SubmitStopOrders), arg0, arg1, arg2, arg3, arg4, arg5)
}

// SucceedMarket mocks base method.
func (m *MockExecutionEngine) SucceedMarket(arg0 context.Context, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SucceedMarket", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SucceedMarket indicates an expected call of SucceedMarket.
func (mr *MockExecutionEngineMockRecorder) SucceedMarket(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SucceedMarket", reflect.TypeOf((*MockExecutionEngine)(nil).SucceedMarket), arg0, arg1, arg2)
}

// UpdateMarginMode mocks base method.
func (m *MockExecutionEngine) UpdateMarginMode(arg0 context.Context, arg1, arg2 string, arg3 vega.MarginMode, arg4 decimal.Decimal) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMarginMode", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMarginMode indicates an expected call of UpdateMarginMode.
func (mr *MockExecutionEngineMockRecorder) UpdateMarginMode(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMarginMode", reflect.TypeOf((*MockExecutionEngine)(nil).UpdateMarginMode), arg0, arg1, arg2, arg3, arg4)
}

// UpdateMarket mocks base method.
func (m *MockExecutionEngine) UpdateMarket(arg0 context.Context, arg1 *types.Market) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMarket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMarket indicates an expected call of UpdateMarket.
func (mr *MockExecutionEngineMockRecorder) UpdateMarket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMarket", reflect.TypeOf((*MockExecutionEngine)(nil).UpdateMarket), arg0, arg1)
}

// UpdateMarketState mocks base method.
func (m *MockExecutionEngine) UpdateMarketState(arg0 context.Context, arg1 *types.MarketStateUpdateConfiguration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMarketState", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMarketState indicates an expected call of UpdateMarketState.
func (mr *MockExecutionEngineMockRecorder) UpdateMarketState(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMarketState", reflect.TypeOf((*MockExecutionEngine)(nil).UpdateMarketState), arg0, arg1)
}

// UpdateSpotMarket mocks base method.
func (m *MockExecutionEngine) UpdateSpotMarket(arg0 context.Context, arg1 *types.Market) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSpotMarket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSpotMarket indicates an expected call of UpdateSpotMarket.
func (mr *MockExecutionEngineMockRecorder) UpdateSpotMarket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSpotMarket", reflect.TypeOf((*MockExecutionEngine)(nil).UpdateSpotMarket), arg0, arg1)
}

// VerifyUpdateMarketState mocks base method.
func (m *MockExecutionEngine) VerifyUpdateMarketState(arg0 *types.MarketStateUpdateConfiguration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyUpdateMarketState", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyUpdateMarketState indicates an expected call of VerifyUpdateMarketState.
func (mr *MockExecutionEngineMockRecorder) VerifyUpdateMarketState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUpdateMarketState", reflect.TypeOf((*MockExecutionEngine)(nil).VerifyUpdateMarketState), arg0)
}

// MockGovernanceEngine is a mock of GovernanceEngine interface.
type MockGovernanceEngine struct {
	ctrl     *gomock.Controller
	recorder *MockGovernanceEngineMockRecorder
}

// MockGovernanceEngineMockRecorder is the mock recorder for MockGovernanceEngine.
type MockGovernanceEngineMockRecorder struct {
	mock *MockGovernanceEngine
}

// NewMockGovernanceEngine creates a new mock instance.
func NewMockGovernanceEngine(ctrl *gomock.Controller) *MockGovernanceEngine {
	mock := &MockGovernanceEngine{ctrl: ctrl}
	mock.recorder = &MockGovernanceEngineMockRecorder{mock}
	return mock
}

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

// AddVote mocks base method.
func (m *MockGovernanceEngine) AddVote(arg0 context.Context, arg1 types.VoteSubmission, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddVote", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddVote indicates an expected call of AddVote.
func (mr *MockGovernanceEngineMockRecorder) AddVote(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVote", reflect.TypeOf((*MockGovernanceEngine)(nil).AddVote), arg0, arg1, arg2)
}

// FinaliseEnactment mocks base method.
func (m *MockGovernanceEngine) FinaliseEnactment(arg0 context.Context, arg1 *types.Proposal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FinaliseEnactment", arg0, arg1)
}

// FinaliseEnactment indicates an expected call of FinaliseEnactment.
func (mr *MockGovernanceEngineMockRecorder) FinaliseEnactment(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinaliseEnactment", reflect.TypeOf((*MockGovernanceEngine)(nil).FinaliseEnactment), arg0, arg1)
}

// Hash mocks base method.
func (m *MockGovernanceEngine) Hash() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hash")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Hash indicates an expected call of Hash.
func (mr *MockGovernanceEngineMockRecorder) Hash() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hash", reflect.TypeOf((*MockGovernanceEngine)(nil).Hash))
}

// OnChainIDUpdate mocks base method.
func (m *MockGovernanceEngine) OnChainIDUpdate(arg0 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnChainIDUpdate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnChainIDUpdate indicates an expected call of OnChainIDUpdate.
func (mr *MockGovernanceEngineMockRecorder) OnChainIDUpdate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnChainIDUpdate", reflect.TypeOf((*MockGovernanceEngine)(nil).OnChainIDUpdate), arg0)
}

// OnTick mocks base method.
func (m *MockGovernanceEngine) OnTick(arg0 context.Context, arg1 time.Time) ([]*governance.ToEnact, []*governance.VoteClosed) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnTick", arg0, arg1)
	ret0, _ := ret[0].([]*governance.ToEnact)
	ret1, _ := ret[1].([]*governance.VoteClosed)
	return ret0, ret1
}

// OnTick indicates an expected call of OnTick.
func (mr *MockGovernanceEngineMockRecorder) OnTick(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnTick", reflect.TypeOf((*MockGovernanceEngine)(nil).OnTick), arg0, arg1)
}

// RejectBatchProposal mocks base method.
func (m *MockGovernanceEngine) RejectBatchProposal(arg0 context.Context, arg1 string, arg2 vega.ProposalError, arg3 error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectBatchProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// RejectBatchProposal indicates an expected call of RejectBatchProposal.
func (mr *MockGovernanceEngineMockRecorder) RejectBatchProposal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectBatchProposal", reflect.TypeOf((*MockGovernanceEngine)(nil).RejectBatchProposal), arg0, arg1, arg2, arg3)
}

// RejectProposal mocks base method.
func (m *MockGovernanceEngine) RejectProposal(arg0 context.Context, arg1 *types.Proposal, arg2 vega.ProposalError, arg3 error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// RejectProposal indicates an expected call of RejectProposal.
func (mr *MockGovernanceEngineMockRecorder) RejectProposal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectProposal", reflect.TypeOf((*MockGovernanceEngine)(nil).RejectProposal), arg0, arg1, arg2, arg3)
}

// SubmitBatchProposal mocks base method.
func (m *MockGovernanceEngine) SubmitBatchProposal(arg0 context.Context, arg1 types.BatchProposalSubmission, arg2, arg3 string) ([]*governance.ToSubmit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitBatchProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*governance.ToSubmit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitBatchProposal indicates an expected call of SubmitBatchProposal.
func (mr *MockGovernanceEngineMockRecorder) SubmitBatchProposal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitBatchProposal", reflect.TypeOf((*MockGovernanceEngine)(nil).SubmitBatchProposal), arg0, arg1, arg2, arg3)
}

// SubmitProposal mocks base method.
func (m *MockGovernanceEngine) SubmitProposal(arg0 context.Context, arg1 types.ProposalSubmission, arg2, arg3 string) (*governance.ToSubmit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*governance.ToSubmit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitProposal indicates an expected call of SubmitProposal.
func (mr *MockGovernanceEngineMockRecorder) SubmitProposal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitProposal", reflect.TypeOf((*MockGovernanceEngine)(nil).SubmitProposal), arg0, arg1, arg2, arg3)
}

// MockStats is a mock of Stats interface.
type MockStats struct {
	ctrl     *gomock.Controller
	recorder *MockStatsMockRecorder
}

// MockStatsMockRecorder is the mock recorder for MockStats.
type MockStatsMockRecorder struct {
	mock *MockStats
}

// NewMockStats creates a new mock instance.
func NewMockStats(ctrl *gomock.Controller) *MockStats {
	mock := &MockStats{ctrl: ctrl}
	mock.recorder = &MockStatsMockRecorder{mock}
	return mock
}

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

// AddCurrentTradesInBatch mocks base method.
func (m *MockStats) AddCurrentTradesInBatch(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddCurrentTradesInBatch", arg0)
}

// AddCurrentTradesInBatch indicates an expected call of AddCurrentTradesInBatch.
func (mr *MockStatsMockRecorder) AddCurrentTradesInBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCurrentTradesInBatch", reflect.TypeOf((*MockStats)(nil).AddCurrentTradesInBatch), arg0)
}

// AddTotalTrades mocks base method.
func (m *MockStats) AddTotalTrades(arg0 uint64) uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTotalTrades", arg0)
	ret0, _ := ret[0].(uint64)
	return ret0
}

// AddTotalTrades indicates an expected call of AddTotalTrades.
func (mr *MockStatsMockRecorder) AddTotalTrades(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTotalTrades", reflect.TypeOf((*MockStats)(nil).AddTotalTrades), arg0)
}

// CurrentEventsInBatch mocks base method.
func (m *MockStats) CurrentEventsInBatch() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentEventsInBatch")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// CurrentEventsInBatch indicates an expected call of CurrentEventsInBatch.
func (mr *MockStatsMockRecorder) CurrentEventsInBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentEventsInBatch", reflect.TypeOf((*MockStats)(nil).CurrentEventsInBatch))
}

// CurrentOrdersInBatch mocks base method.
func (m *MockStats) CurrentOrdersInBatch() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentOrdersInBatch")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// CurrentOrdersInBatch indicates an expected call of CurrentOrdersInBatch.
func (mr *MockStatsMockRecorder) CurrentOrdersInBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentOrdersInBatch", reflect.TypeOf((*MockStats)(nil).CurrentOrdersInBatch))
}

// CurrentTradesInBatch mocks base method.
func (m *MockStats) CurrentTradesInBatch() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentTradesInBatch")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// CurrentTradesInBatch indicates an expected call of CurrentTradesInBatch.
func (mr *MockStatsMockRecorder) CurrentTradesInBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentTradesInBatch", reflect.TypeOf((*MockStats)(nil).CurrentTradesInBatch))
}

// Height mocks base method.
func (m *MockStats) Height() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Height")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Height indicates an expected call of Height.
func (mr *MockStatsMockRecorder) Height() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockStats)(nil).Height))
}

// IncCurrentOrdersInBatch mocks base method.
func (m *MockStats) IncCurrentOrdersInBatch() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncCurrentOrdersInBatch")
}

// IncCurrentOrdersInBatch indicates an expected call of IncCurrentOrdersInBatch.
func (mr *MockStatsMockRecorder) IncCurrentOrdersInBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncCurrentOrdersInBatch", reflect.TypeOf((*MockStats)(nil).IncCurrentOrdersInBatch))
}

// IncHeight mocks base method.
func (m *MockStats) IncHeight() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncHeight")
}

// IncHeight indicates an expected call of IncHeight.
func (mr *MockStatsMockRecorder) IncHeight() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncHeight", reflect.TypeOf((*MockStats)(nil).IncHeight))
}

// IncTotalAmendOrder mocks base method.
func (m *MockStats) IncTotalAmendOrder() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalAmendOrder")
}

// IncTotalAmendOrder indicates an expected call of IncTotalAmendOrder.
func (mr *MockStatsMockRecorder) IncTotalAmendOrder() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalAmendOrder", reflect.TypeOf((*MockStats)(nil).IncTotalAmendOrder))
}

// IncTotalBatches mocks base method.
func (m *MockStats) IncTotalBatches() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalBatches")
}

// IncTotalBatches indicates an expected call of IncTotalBatches.
func (mr *MockStatsMockRecorder) IncTotalBatches() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalBatches", reflect.TypeOf((*MockStats)(nil).IncTotalBatches))
}

// IncTotalCancelOrder mocks base method.
func (m *MockStats) IncTotalCancelOrder() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalCancelOrder")
}

// IncTotalCancelOrder indicates an expected call of IncTotalCancelOrder.
func (mr *MockStatsMockRecorder) IncTotalCancelOrder() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalCancelOrder", reflect.TypeOf((*MockStats)(nil).IncTotalCancelOrder))
}

// IncTotalCreateOrder mocks base method.
func (m *MockStats) IncTotalCreateOrder() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalCreateOrder")
}

// IncTotalCreateOrder indicates an expected call of IncTotalCreateOrder.
func (mr *MockStatsMockRecorder) IncTotalCreateOrder() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalCreateOrder", reflect.TypeOf((*MockStats)(nil).IncTotalCreateOrder))
}

// IncTotalOrders mocks base method.
func (m *MockStats) IncTotalOrders() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalOrders")
}

// IncTotalOrders indicates an expected call of IncTotalOrders.
func (mr *MockStatsMockRecorder) IncTotalOrders() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalOrders", reflect.TypeOf((*MockStats)(nil).IncTotalOrders))
}

// IncTotalTxCurrentBatch mocks base method.
func (m *MockStats) IncTotalTxCurrentBatch() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalTxCurrentBatch")
}

// IncTotalTxCurrentBatch indicates an expected call of IncTotalTxCurrentBatch.
func (mr *MockStatsMockRecorder) IncTotalTxCurrentBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalTxCurrentBatch", reflect.TypeOf((*MockStats)(nil).IncTotalTxCurrentBatch))
}

// NewBatch mocks base method.
func (m *MockStats) NewBatch() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NewBatch")
}

// NewBatch indicates an expected call of NewBatch.
func (mr *MockStatsMockRecorder) NewBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBatch", reflect.TypeOf((*MockStats)(nil).NewBatch))
}

// SetAverageOrdersPerBatch mocks base method.
func (m *MockStats) SetAverageOrdersPerBatch(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAverageOrdersPerBatch", arg0)
}

// SetAverageOrdersPerBatch indicates an expected call of SetAverageOrdersPerBatch.
func (mr *MockStatsMockRecorder) SetAverageOrdersPerBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAverageOrdersPerBatch", reflect.TypeOf((*MockStats)(nil).SetAverageOrdersPerBatch), arg0)
}

// SetAverageTxPerBatch mocks base method.
func (m *MockStats) SetAverageTxPerBatch(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAverageTxPerBatch", arg0)
}

// SetAverageTxPerBatch indicates an expected call of SetAverageTxPerBatch.
func (mr *MockStatsMockRecorder) SetAverageTxPerBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAverageTxPerBatch", reflect.TypeOf((*MockStats)(nil).SetAverageTxPerBatch), arg0)
}

// SetAverageTxSizeBytes mocks base method.
func (m *MockStats) SetAverageTxSizeBytes(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAverageTxSizeBytes", arg0)
}

// SetAverageTxSizeBytes indicates an expected call of SetAverageTxSizeBytes.
func (mr *MockStatsMockRecorder) SetAverageTxSizeBytes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAverageTxSizeBytes", reflect.TypeOf((*MockStats)(nil).SetAverageTxSizeBytes), arg0)
}

// SetBlockDuration mocks base method.
func (m *MockStats) SetBlockDuration(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBlockDuration", arg0)
}

// SetBlockDuration indicates an expected call of SetBlockDuration.
func (mr *MockStatsMockRecorder) SetBlockDuration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBlockDuration", reflect.TypeOf((*MockStats)(nil).SetBlockDuration), arg0)
}

// SetEventsPerSecond mocks base method.
func (m *MockStats) SetEventsPerSecond(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEventsPerSecond", arg0)
}

// SetEventsPerSecond indicates an expected call of SetEventsPerSecond.
func (mr *MockStatsMockRecorder) SetEventsPerSecond(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEventsPerSecond", reflect.TypeOf((*MockStats)(nil).SetEventsPerSecond), arg0)
}

// SetHash mocks base method.
func (m *MockStats) SetHash(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHash", arg0)
}

// SetHash indicates an expected call of SetHash.
func (mr *MockStatsMockRecorder) SetHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHash", reflect.TypeOf((*MockStats)(nil).SetHash), arg0)
}

// SetHeight mocks base method.
func (m *MockStats) SetHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHeight", arg0)
}

// SetHeight indicates an expected call of SetHeight.
func (mr *MockStatsMockRecorder) SetHeight(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeight", reflect.TypeOf((*MockStats)(nil).SetHeight), arg0)
}

// SetOrdersPerSecond mocks base method.
func (m *MockStats) SetOrdersPerSecond(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOrdersPerSecond", arg0)
}

// SetOrdersPerSecond indicates an expected call of SetOrdersPerSecond.
func (mr *MockStatsMockRecorder) SetOrdersPerSecond(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOrdersPerSecond", reflect.TypeOf((*MockStats)(nil).SetOrdersPerSecond), arg0)
}

// SetTotalTxCurrentBatch mocks base method.
func (m *MockStats) SetTotalTxCurrentBatch(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTotalTxCurrentBatch", arg0)
}

// SetTotalTxCurrentBatch indicates an expected call of SetTotalTxCurrentBatch.
func (mr *MockStatsMockRecorder) SetTotalTxCurrentBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTotalTxCurrentBatch", reflect.TypeOf((*MockStats)(nil).SetTotalTxCurrentBatch), arg0)
}

// SetTotalTxLastBatch mocks base method.
func (m *MockStats) SetTotalTxLastBatch(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTotalTxLastBatch", arg0)
}

// SetTotalTxLastBatch indicates an expected call of SetTotalTxLastBatch.
func (mr *MockStatsMockRecorder) SetTotalTxLastBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTotalTxLastBatch", reflect.TypeOf((*MockStats)(nil).SetTotalTxLastBatch), arg0)
}

// SetTradesPerSecond mocks base method.
func (m *MockStats) SetTradesPerSecond(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTradesPerSecond", arg0)
}

// SetTradesPerSecond indicates an expected call of SetTradesPerSecond.
func (mr *MockStatsMockRecorder) SetTradesPerSecond(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTradesPerSecond", reflect.TypeOf((*MockStats)(nil).SetTradesPerSecond), arg0)
}

// TotalBatches mocks base method.
func (m *MockStats) TotalBatches() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TotalBatches")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// TotalBatches indicates an expected call of TotalBatches.
func (mr *MockStatsMockRecorder) TotalBatches() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalBatches", reflect.TypeOf((*MockStats)(nil).TotalBatches))
}

// TotalOrders mocks base method.
func (m *MockStats) TotalOrders() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TotalOrders")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// TotalOrders indicates an expected call of TotalOrders.
func (mr *MockStatsMockRecorder) TotalOrders() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalOrders", reflect.TypeOf((*MockStats)(nil).TotalOrders))
}

// TotalTxCurrentBatch mocks base method.
func (m *MockStats) TotalTxCurrentBatch() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TotalTxCurrentBatch")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// TotalTxCurrentBatch indicates an expected call of TotalTxCurrentBatch.
func (mr *MockStatsMockRecorder) TotalTxCurrentBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalTxCurrentBatch", reflect.TypeOf((*MockStats)(nil).TotalTxCurrentBatch))
}

// TotalTxLastBatch mocks base method.
func (m *MockStats) TotalTxLastBatch() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TotalTxLastBatch")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// TotalTxLastBatch indicates an expected call of TotalTxLastBatch.
func (mr *MockStatsMockRecorder) TotalTxLastBatch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalTxLastBatch", reflect.TypeOf((*MockStats)(nil).TotalTxLastBatch))
}

// MockAssets is a mock of Assets interface.
type MockAssets struct {
	ctrl     *gomock.Controller
	recorder *MockAssetsMockRecorder
}

// MockAssetsMockRecorder is the mock recorder for MockAssets.
type MockAssetsMockRecorder struct {
	mock *MockAssets
}

// NewMockAssets creates a new mock instance.
func NewMockAssets(ctrl *gomock.Controller) *MockAssets {
	mock := &MockAssets{ctrl: ctrl}
	mock.recorder = &MockAssetsMockRecorder{mock}
	return mock
}

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

// EnactPendingAsset mocks base method.
func (m *MockAssets) EnactPendingAsset(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnactPendingAsset", arg0)
}

// EnactPendingAsset indicates an expected call of EnactPendingAsset.
func (mr *MockAssetsMockRecorder) EnactPendingAsset(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnactPendingAsset", reflect.TypeOf((*MockAssets)(nil).EnactPendingAsset), arg0)
}

// Get mocks base method.
func (m *MockAssets) Get(arg0 string) (*assets.Asset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(*assets.Asset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAssetsMockRecorder) Get(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAssets)(nil).Get), arg0)
}

// IsEnabled mocks base method.
func (m *MockAssets) IsEnabled(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsEnabled", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsEnabled indicates an expected call of IsEnabled.
func (mr *MockAssetsMockRecorder) IsEnabled(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEnabled", reflect.TypeOf((*MockAssets)(nil).IsEnabled), arg0)
}

// NewAsset mocks base method.
func (m *MockAssets) NewAsset(arg0 context.Context, arg1 string, arg2 *types.AssetDetails) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAsset", arg0, arg1, arg2)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewAsset indicates an expected call of NewAsset.
func (mr *MockAssetsMockRecorder) NewAsset(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAsset", reflect.TypeOf((*MockAssets)(nil).NewAsset), arg0, arg1, arg2)
}

// StageAssetUpdate mocks base method.
func (m *MockAssets) StageAssetUpdate(arg0 *types.Asset) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StageAssetUpdate", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// StageAssetUpdate indicates an expected call of StageAssetUpdate.
func (mr *MockAssetsMockRecorder) StageAssetUpdate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StageAssetUpdate", reflect.TypeOf((*MockAssets)(nil).StageAssetUpdate), arg0)
}

// MockValidatorTopology is a mock of ValidatorTopology interface.
type MockValidatorTopology struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorTopologyMockRecorder
}

// MockValidatorTopologyMockRecorder is the mock recorder for MockValidatorTopology.
type MockValidatorTopologyMockRecorder struct {
	mock *MockValidatorTopology
}

// NewMockValidatorTopology creates a new mock instance.
func NewMockValidatorTopology(ctrl *gomock.Controller) *MockValidatorTopology {
	mock := &MockValidatorTopology{ctrl: ctrl}
	mock.recorder = &MockValidatorTopologyMockRecorder{mock}
	return mock
}

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

// AddForwarder mocks base method.
func (m *MockValidatorTopology) AddForwarder(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddForwarder", arg0)
}

// AddForwarder indicates an expected call of AddForwarder.
func (mr *MockValidatorTopologyMockRecorder) AddForwarder(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddForwarder", reflect.TypeOf((*MockValidatorTopology)(nil).AddForwarder), arg0)
}

// AddKeyRotate mocks base method.
func (m *MockValidatorTopology) AddKeyRotate(arg0 context.Context, arg1 string, arg2 uint64, arg3 *v10.KeyRotateSubmission) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddKeyRotate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddKeyRotate indicates an expected call of AddKeyRotate.
func (mr *MockValidatorTopologyMockRecorder) AddKeyRotate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddKeyRotate", reflect.TypeOf((*MockValidatorTopology)(nil).AddKeyRotate), arg0, arg1, arg2, arg3)
}

// AllVegaPubKeys mocks base method.
func (m *MockValidatorTopology) AllVegaPubKeys() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllVegaPubKeys")
	ret0, _ := ret[0].([]string)
	return ret0
}

// AllVegaPubKeys indicates an expected call of AllVegaPubKeys.
func (mr *MockValidatorTopologyMockRecorder) AllVegaPubKeys() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllVegaPubKeys", reflect.TypeOf((*MockValidatorTopology)(nil).AllVegaPubKeys))
}

// BeginBlock mocks base method.
func (m *MockValidatorTopology) BeginBlock(arg0 context.Context, arg1 uint64, arg2 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0, arg1, arg2)
}

// BeginBlock indicates an expected call of BeginBlock.
func (mr *MockValidatorTopologyMockRecorder) BeginBlock(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockValidatorTopology)(nil).BeginBlock), arg0, arg1, arg2)
}

// GetValidatorPowerUpdates mocks base method.
func (m *MockValidatorTopology) GetValidatorPowerUpdates() []types0.ValidatorUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValidatorPowerUpdates")
	ret0, _ := ret[0].([]types0.ValidatorUpdate)
	return ret0
}

// GetValidatorPowerUpdates indicates an expected call of GetValidatorPowerUpdates.
func (mr *MockValidatorTopologyMockRecorder) GetValidatorPowerUpdates() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorPowerUpdates", reflect.TypeOf((*MockValidatorTopology)(nil).GetValidatorPowerUpdates))
}

// IsValidator mocks base method.
func (m *MockValidatorTopology) IsValidator() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsValidator")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsValidator indicates an expected call of IsValidator.
func (mr *MockValidatorTopologyMockRecorder) IsValidator() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidator", reflect.TypeOf((*MockValidatorTopology)(nil).IsValidator))
}

// IsValidatorNodeID mocks base method.
func (m *MockValidatorTopology) IsValidatorNodeID(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsValidatorNodeID", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsValidatorNodeID indicates an expected call of IsValidatorNodeID.
func (mr *MockValidatorTopologyMockRecorder) IsValidatorNodeID(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidatorNodeID", reflect.TypeOf((*MockValidatorTopology)(nil).IsValidatorNodeID), arg0)
}

// IsValidatorVegaPubKey mocks base method.
func (m *MockValidatorTopology) IsValidatorVegaPubKey(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsValidatorVegaPubKey", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsValidatorVegaPubKey indicates an expected call of IsValidatorVegaPubKey.
func (mr *MockValidatorTopologyMockRecorder) IsValidatorVegaPubKey(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidatorVegaPubKey", reflect.TypeOf((*MockValidatorTopology)(nil).IsValidatorVegaPubKey), arg0)
}

// IssueSignatures mocks base method.
func (m *MockValidatorTopology) IssueSignatures(arg0 context.Context, arg1, arg2, arg3 string, arg4 v10.NodeSignatureKind) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssueSignatures", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// IssueSignatures indicates an expected call of IssueSignatures.
func (mr *MockValidatorTopologyMockRecorder) IssueSignatures(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssueSignatures", reflect.TypeOf((*MockValidatorTopology)(nil).IssueSignatures), arg0, arg1, arg2, arg3, arg4)
}

// Len mocks base method.
func (m *MockValidatorTopology) Len() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Len")
	ret0, _ := ret[0].(int)
	return ret0
}

// Len indicates an expected call of Len.
func (mr *MockValidatorTopologyMockRecorder) Len() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockValidatorTopology)(nil).Len))
}

// ProcessAnnounceNode mocks base method.
func (m *MockValidatorTopology) ProcessAnnounceNode(arg0 context.Context, arg1 *v10.AnnounceNode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessAnnounceNode", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessAnnounceNode indicates an expected call of ProcessAnnounceNode.
func (mr *MockValidatorTopologyMockRecorder) ProcessAnnounceNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessAnnounceNode", reflect.TypeOf((*MockValidatorTopology)(nil).ProcessAnnounceNode), arg0, arg1)
}

// ProcessEthereumKeyRotation mocks base method.
func (m *MockValidatorTopology) ProcessEthereumKeyRotation(arg0 context.Context, arg1 string, arg2 *v10.EthereumKeyRotateSubmission, arg3 func([]byte, []byte, string) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessEthereumKeyRotation", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessEthereumKeyRotation indicates an expected call of ProcessEthereumKeyRotation.
func (mr *MockValidatorTopologyMockRecorder) ProcessEthereumKeyRotation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessEthereumKeyRotation", reflect.TypeOf((*MockValidatorTopology)(nil).ProcessEthereumKeyRotation), arg0, arg1, arg2, arg3)
}

// ProcessValidatorHeartbeat mocks base method.
func (m *MockValidatorTopology) ProcessValidatorHeartbeat(arg0 context.Context, arg1 *v10.ValidatorHeartbeat, arg2 func([]byte, []byte, []byte) error, arg3 func([]byte, []byte, string) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessValidatorHeartbeat", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessValidatorHeartbeat indicates an expected call of ProcessValidatorHeartbeat.
func (mr *MockValidatorTopologyMockRecorder) ProcessValidatorHeartbeat(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessValidatorHeartbeat", reflect.TypeOf((*MockValidatorTopology)(nil).ProcessValidatorHeartbeat), arg0, arg1, arg2, arg3)
}

// MockNotary is a mock of Notary interface.
type MockNotary struct {
	ctrl     *gomock.Controller
	recorder *MockNotaryMockRecorder
}

// MockNotaryMockRecorder is the mock recorder for MockNotary.
type MockNotaryMockRecorder struct {
	mock *MockNotary
}

// NewMockNotary creates a new mock instance.
func NewMockNotary(ctrl *gomock.Controller) *MockNotary {
	mock := &MockNotary{ctrl: ctrl}
	mock.recorder = &MockNotaryMockRecorder{mock}
	return mock
}

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

// IsSigned mocks base method.
func (m *MockNotary) IsSigned(arg0 context.Context, arg1 string, arg2 v10.NodeSignatureKind) ([]v10.NodeSignature, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSigned", arg0, arg1, arg2)
	ret0, _ := ret[0].([]v10.NodeSignature)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// IsSigned indicates an expected call of IsSigned.
func (mr *MockNotaryMockRecorder) IsSigned(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSigned", reflect.TypeOf((*MockNotary)(nil).IsSigned), arg0, arg1, arg2)
}

// RegisterSignature mocks base method.
func (m *MockNotary) RegisterSignature(arg0 context.Context, arg1 string, arg2 v10.NodeSignature) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterSignature", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterSignature indicates an expected call of RegisterSignature.
func (mr *MockNotaryMockRecorder) RegisterSignature(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterSignature", reflect.TypeOf((*MockNotary)(nil).RegisterSignature), arg0, arg1, arg2)
}

// StartAggregate mocks base method.
func (m *MockNotary) StartAggregate(arg0 string, arg1 v10.NodeSignatureKind, arg2 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartAggregate", arg0, arg1, arg2)
}

// StartAggregate indicates an expected call of StartAggregate.
func (mr *MockNotaryMockRecorder) StartAggregate(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAggregate", reflect.TypeOf((*MockNotary)(nil).StartAggregate), arg0, arg1, arg2)
}

// MockEvtForwarder is a mock of EvtForwarder interface.
type MockEvtForwarder struct {
	ctrl     *gomock.Controller
	recorder *MockEvtForwarderMockRecorder
}

// MockEvtForwarderMockRecorder is the mock recorder for MockEvtForwarder.
type MockEvtForwarderMockRecorder struct {
	mock *MockEvtForwarder
}

// NewMockEvtForwarder creates a new mock instance.
func NewMockEvtForwarder(ctrl *gomock.Controller) *MockEvtForwarder {
	mock := &MockEvtForwarder{ctrl: ctrl}
	mock.recorder = &MockEvtForwarderMockRecorder{mock}
	return mock
}

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

// Ack mocks base method.
func (m *MockEvtForwarder) Ack(arg0 *v10.ChainEvent) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ack", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Ack indicates an expected call of Ack.
func (mr *MockEvtForwarderMockRecorder) Ack(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ack", reflect.TypeOf((*MockEvtForwarder)(nil).Ack), arg0)
}

// MockEvtForwarderHeartbeat is a mock of EvtForwarderHeartbeat interface.
type MockEvtForwarderHeartbeat struct {
	ctrl     *gomock.Controller
	recorder *MockEvtForwarderHeartbeatMockRecorder
}

// MockEvtForwarderHeartbeatMockRecorder is the mock recorder for MockEvtForwarderHeartbeat.
type MockEvtForwarderHeartbeatMockRecorder struct {
	mock *MockEvtForwarderHeartbeat
}

// NewMockEvtForwarderHeartbeat creates a new mock instance.
func NewMockEvtForwarderHeartbeat(ctrl *gomock.Controller) *MockEvtForwarderHeartbeat {
	mock := &MockEvtForwarderHeartbeat{ctrl: ctrl}
	mock.recorder = &MockEvtForwarderHeartbeatMockRecorder{mock}
	return mock
}

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

// ProcessHeartbeat mocks base method.
func (m *MockEvtForwarderHeartbeat) ProcessHeartbeat(arg0, arg1 string, arg2, arg3 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessHeartbeat", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessHeartbeat indicates an expected call of ProcessHeartbeat.
func (mr *MockEvtForwarderHeartbeatMockRecorder) ProcessHeartbeat(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessHeartbeat", reflect.TypeOf((*MockEvtForwarderHeartbeat)(nil).ProcessHeartbeat), arg0, arg1, arg2, arg3)
}

// MockWitness is a mock of Witness interface.
type MockWitness struct {
	ctrl     *gomock.Controller
	recorder *MockWitnessMockRecorder
}

// MockWitnessMockRecorder is the mock recorder for MockWitness.
type MockWitnessMockRecorder struct {
	mock *MockWitness
}

// NewMockWitness creates a new mock instance.
func NewMockWitness(ctrl *gomock.Controller) *MockWitness {
	mock := &MockWitness{ctrl: ctrl}
	mock.recorder = &MockWitnessMockRecorder{mock}
	return mock
}

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

// AddNodeCheck mocks base method.
func (m *MockWitness) AddNodeCheck(arg0 context.Context, arg1 *v10.NodeVote, arg2 crypto.PublicKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNodeCheck", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddNodeCheck indicates an expected call of AddNodeCheck.
func (mr *MockWitnessMockRecorder) AddNodeCheck(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNodeCheck", reflect.TypeOf((*MockWitness)(nil).AddNodeCheck), arg0, arg1, arg2)
}

// MockBanking is a mock of Banking interface.
type MockBanking struct {
	ctrl     *gomock.Controller
	recorder *MockBankingMockRecorder
}

// MockBankingMockRecorder is the mock recorder for MockBanking.
type MockBankingMockRecorder struct {
	mock *MockBanking
}

// NewMockBanking creates a new mock instance.
func NewMockBanking(ctrl *gomock.Controller) *MockBanking {
	mock := &MockBanking{ctrl: ctrl}
	mock.recorder = &MockBankingMockRecorder{mock}
	return mock
}

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

// BridgeResumed mocks base method.
func (m *MockBanking) BridgeResumed(arg0 context.Context, arg1 bool, arg2 string, arg3, arg4 uint64, arg5, arg6 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BridgeResumed", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// BridgeResumed indicates an expected call of BridgeResumed.
func (mr *MockBankingMockRecorder) BridgeResumed(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BridgeResumed", reflect.TypeOf((*MockBanking)(nil).BridgeResumed), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// BridgeStopped mocks base method.
func (m *MockBanking) BridgeStopped(arg0 context.Context, arg1 bool, arg2 string, arg3, arg4 uint64, arg5, arg6 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BridgeStopped", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// BridgeStopped indicates an expected call of BridgeStopped.
func (mr *MockBankingMockRecorder) BridgeStopped(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BridgeStopped", reflect.TypeOf((*MockBanking)(nil).BridgeStopped), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// CancelGovTransfer mocks base method.
func (m *MockBanking) CancelGovTransfer(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelGovTransfer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelGovTransfer indicates an expected call of CancelGovTransfer.
func (mr *MockBankingMockRecorder) CancelGovTransfer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelGovTransfer", reflect.TypeOf((*MockBanking)(nil).CancelGovTransfer), arg0, arg1)
}

// CancelTransferFunds mocks base method.
func (m *MockBanking) CancelTransferFunds(arg0 context.Context, arg1 *types.CancelTransferFunds) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelTransferFunds", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelTransferFunds indicates an expected call of CancelTransferFunds.
func (mr *MockBankingMockRecorder) CancelTransferFunds(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelTransferFunds", reflect.TypeOf((*MockBanking)(nil).CancelTransferFunds), arg0, arg1)
}

// CheckTransfer mocks base method.
func (m *MockBanking) CheckTransfer(arg0 *types.TransferBase) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckTransfer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckTransfer indicates an expected call of CheckTransfer.
func (mr *MockBankingMockRecorder) CheckTransfer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTransfer", reflect.TypeOf((*MockBanking)(nil).CheckTransfer), arg0)
}

// DepositBuiltinAsset mocks base method.
func (m *MockBanking) DepositBuiltinAsset(arg0 context.Context, arg1 *types.BuiltinAssetDeposit, arg2 string, arg3 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DepositBuiltinAsset", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// DepositBuiltinAsset indicates an expected call of DepositBuiltinAsset.
func (mr *MockBankingMockRecorder) DepositBuiltinAsset(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepositBuiltinAsset", reflect.TypeOf((*MockBanking)(nil).DepositBuiltinAsset), arg0, arg1, arg2, arg3)
}

// DepositERC20 mocks base method.
func (m *MockBanking) DepositERC20(arg0 context.Context, arg1 *types.ERC20Deposit, arg2 string, arg3, arg4 uint64, arg5, arg6 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DepositERC20", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// DepositERC20 indicates an expected call of DepositERC20.
func (mr *MockBankingMockRecorder) DepositERC20(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepositERC20", reflect.TypeOf((*MockBanking)(nil).DepositERC20), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// ERC20WithdrawalEvent mocks base method.
func (m *MockBanking) ERC20WithdrawalEvent(arg0 context.Context, arg1 *types.ERC20Withdrawal, arg2 uint64, arg3, arg4 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ERC20WithdrawalEvent", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// ERC20WithdrawalEvent indicates an expected call of ERC20WithdrawalEvent.
func (mr *MockBankingMockRecorder) ERC20WithdrawalEvent(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ERC20WithdrawalEvent", reflect.TypeOf((*MockBanking)(nil).ERC20WithdrawalEvent), arg0, arg1, arg2, arg3, arg4)
}

// EnableBuiltinAsset mocks base method.
func (m *MockBanking) EnableBuiltinAsset(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableBuiltinAsset", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnableBuiltinAsset indicates an expected call of EnableBuiltinAsset.
func (mr *MockBankingMockRecorder) EnableBuiltinAsset(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableBuiltinAsset", reflect.TypeOf((*MockBanking)(nil).EnableBuiltinAsset), arg0, arg1)
}

// EnableERC20 mocks base method.
func (m *MockBanking) EnableERC20(arg0 context.Context, arg1 *types.ERC20AssetList, arg2 string, arg3, arg4 uint64, arg5, arg6 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableERC20", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnableERC20 indicates an expected call of EnableERC20.
func (mr *MockBankingMockRecorder) EnableERC20(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableERC20", reflect.TypeOf((*MockBanking)(nil).EnableERC20), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// NewGovernanceTransfer mocks base method.
func (m *MockBanking) NewGovernanceTransfer(arg0 context.Context, arg1, arg2 string, arg3 *types.NewTransferConfiguration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGovernanceTransfer", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// NewGovernanceTransfer indicates an expected call of NewGovernanceTransfer.
func (mr *MockBankingMockRecorder) NewGovernanceTransfer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGovernanceTransfer", reflect.TypeOf((*MockBanking)(nil).NewGovernanceTransfer), arg0, arg1, arg2, arg3)
}

// OnBlockEnd mocks base method.
func (m *MockBanking) OnBlockEnd(arg0 context.Context, arg1 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnBlockEnd", arg0, arg1)
}

// OnBlockEnd indicates an expected call of OnBlockEnd.
func (mr *MockBankingMockRecorder) OnBlockEnd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnBlockEnd", reflect.TypeOf((*MockBanking)(nil).OnBlockEnd), arg0, arg1)
}

// TransferFunds mocks base method.
func (m *MockBanking) TransferFunds(arg0 context.Context, arg1 *types.TransferFunds) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferFunds", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// TransferFunds indicates an expected call of TransferFunds.
func (mr *MockBankingMockRecorder) TransferFunds(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferFunds", reflect.TypeOf((*MockBanking)(nil).TransferFunds), arg0, arg1)
}

// UpdateERC20 mocks base method.
func (m *MockBanking) UpdateERC20(arg0 context.Context, arg1 *types.ERC20AssetLimitsUpdated, arg2 string, arg3, arg4 uint64, arg5, arg6 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateERC20", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateERC20 indicates an expected call of UpdateERC20.
func (mr *MockBankingMockRecorder) UpdateERC20(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateERC20", reflect.TypeOf((*MockBanking)(nil).UpdateERC20), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// VerifyCancelGovernanceTransfer mocks base method.
func (m *MockBanking) VerifyCancelGovernanceTransfer(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyCancelGovernanceTransfer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyCancelGovernanceTransfer indicates an expected call of VerifyCancelGovernanceTransfer.
func (mr *MockBankingMockRecorder) VerifyCancelGovernanceTransfer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyCancelGovernanceTransfer", reflect.TypeOf((*MockBanking)(nil).VerifyCancelGovernanceTransfer), arg0)
}

// VerifyGovernanceTransfer mocks base method.
func (m *MockBanking) VerifyGovernanceTransfer(arg0 *types.NewTransferConfiguration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyGovernanceTransfer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyGovernanceTransfer indicates an expected call of VerifyGovernanceTransfer.
func (mr *MockBankingMockRecorder) VerifyGovernanceTransfer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGovernanceTransfer", reflect.TypeOf((*MockBanking)(nil).VerifyGovernanceTransfer), arg0)
}

// WithdrawBuiltinAsset mocks base method.
func (m *MockBanking) WithdrawBuiltinAsset(arg0 context.Context, arg1, arg2, arg3 string, arg4 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithdrawBuiltinAsset", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// WithdrawBuiltinAsset indicates an expected call of WithdrawBuiltinAsset.
func (mr *MockBankingMockRecorder) WithdrawBuiltinAsset(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawBuiltinAsset", reflect.TypeOf((*MockBanking)(nil).WithdrawBuiltinAsset), arg0, arg1, arg2, arg3, arg4)
}

// WithdrawERC20 mocks base method.
func (m *MockBanking) WithdrawERC20(arg0 context.Context, arg1, arg2, arg3 string, arg4 *num.Uint, arg5 *types.Erc20WithdrawExt) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithdrawERC20", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// WithdrawERC20 indicates an expected call of WithdrawERC20.
func (mr *MockBankingMockRecorder) WithdrawERC20(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawERC20", reflect.TypeOf((*MockBanking)(nil).WithdrawERC20), arg0, arg1, arg2, arg3, arg4, arg5)
}

// MockNetworkParameters is a mock of NetworkParameters interface.
type MockNetworkParameters struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkParametersMockRecorder
}

// MockNetworkParametersMockRecorder is the mock recorder for MockNetworkParameters.
type MockNetworkParametersMockRecorder struct {
	mock *MockNetworkParameters
}

// NewMockNetworkParameters creates a new mock instance.
func NewMockNetworkParameters(ctrl *gomock.Controller) *MockNetworkParameters {
	mock := &MockNetworkParameters{ctrl: ctrl}
	mock.recorder = &MockNetworkParametersMockRecorder{mock}
	return mock
}

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

// DispatchChanges mocks base method.
func (m *MockNetworkParameters) DispatchChanges(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DispatchChanges", arg0)
}

// DispatchChanges indicates an expected call of DispatchChanges.
func (mr *MockNetworkParametersMockRecorder) DispatchChanges(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchChanges", reflect.TypeOf((*MockNetworkParameters)(nil).DispatchChanges), arg0)
}

// GetInt mocks base method.
func (m *MockNetworkParameters) GetInt(arg0 string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInt", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInt indicates an expected call of GetInt.
func (mr *MockNetworkParametersMockRecorder) GetInt(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInt", reflect.TypeOf((*MockNetworkParameters)(nil).GetInt), arg0)
}

// GetJSONStruct mocks base method.
func (m *MockNetworkParameters) GetJSONStruct(arg0 string, arg1 netparams.Reset) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJSONStruct", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetJSONStruct indicates an expected call of GetJSONStruct.
func (mr *MockNetworkParametersMockRecorder) GetJSONStruct(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJSONStruct", reflect.TypeOf((*MockNetworkParameters)(nil).GetJSONStruct), arg0, arg1)
}

// IsUpdateAllowed mocks base method.
func (m *MockNetworkParameters) IsUpdateAllowed(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUpdateAllowed", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// IsUpdateAllowed indicates an expected call of IsUpdateAllowed.
func (mr *MockNetworkParametersMockRecorder) IsUpdateAllowed(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpdateAllowed", reflect.TypeOf((*MockNetworkParameters)(nil).IsUpdateAllowed), arg0)
}

// Update mocks base method.
func (m *MockNetworkParameters) Update(arg0 context.Context, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockNetworkParametersMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNetworkParameters)(nil).Update), arg0, arg1, arg2)
}

// MockOraclesEngine is a mock of OraclesEngine interface.
type MockOraclesEngine struct {
	ctrl     *gomock.Controller
	recorder *MockOraclesEngineMockRecorder
}

// MockOraclesEngineMockRecorder is the mock recorder for MockOraclesEngine.
type MockOraclesEngineMockRecorder struct {
	mock *MockOraclesEngine
}

// NewMockOraclesEngine creates a new mock instance.
func NewMockOraclesEngine(ctrl *gomock.Controller) *MockOraclesEngine {
	mock := &MockOraclesEngine{ctrl: ctrl}
	mock.recorder = &MockOraclesEngineMockRecorder{mock}
	return mock
}

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

// BroadcastData mocks base method.
func (m *MockOraclesEngine) BroadcastData(arg0 context.Context, arg1 common.Data) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BroadcastData", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// BroadcastData indicates an expected call of BroadcastData.
func (mr *MockOraclesEngineMockRecorder) BroadcastData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastData", reflect.TypeOf((*MockOraclesEngine)(nil).BroadcastData), arg0, arg1)
}

// HasMatch mocks base method.
func (m *MockOraclesEngine) HasMatch(arg0 common.Data) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasMatch", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasMatch indicates an expected call of HasMatch.
func (mr *MockOraclesEngineMockRecorder) HasMatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasMatch", reflect.TypeOf((*MockOraclesEngine)(nil).HasMatch), arg0)
}

// ListensToSigners mocks base method.
func (m *MockOraclesEngine) ListensToSigners(arg0 common.Data) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListensToSigners", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ListensToSigners indicates an expected call of ListensToSigners.
func (mr *MockOraclesEngineMockRecorder) ListensToSigners(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListensToSigners", reflect.TypeOf((*MockOraclesEngine)(nil).ListensToSigners), arg0)
}

// MockOracleAdaptors is a mock of OracleAdaptors interface.
type MockOracleAdaptors struct {
	ctrl     *gomock.Controller
	recorder *MockOracleAdaptorsMockRecorder
}

// MockOracleAdaptorsMockRecorder is the mock recorder for MockOracleAdaptors.
type MockOracleAdaptorsMockRecorder struct {
	mock *MockOracleAdaptors
}

// NewMockOracleAdaptors creates a new mock instance.
func NewMockOracleAdaptors(ctrl *gomock.Controller) *MockOracleAdaptors {
	mock := &MockOracleAdaptors{ctrl: ctrl}
	mock.recorder = &MockOracleAdaptorsMockRecorder{mock}
	return mock
}

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

// Normalise mocks base method.
func (m *MockOracleAdaptors) Normalise(arg0 crypto.PublicKey, arg1 v10.OracleDataSubmission) (*common.Data, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Normalise", arg0, arg1)
	ret0, _ := ret[0].(*common.Data)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Normalise indicates an expected call of Normalise.
func (mr *MockOracleAdaptorsMockRecorder) Normalise(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Normalise", reflect.TypeOf((*MockOracleAdaptors)(nil).Normalise), arg0, arg1)
}

// MockLimits is a mock of Limits interface.
type MockLimits struct {
	ctrl     *gomock.Controller
	recorder *MockLimitsMockRecorder
}

// MockLimitsMockRecorder is the mock recorder for MockLimits.
type MockLimitsMockRecorder struct {
	mock *MockLimits
}

// NewMockLimits creates a new mock instance.
func NewMockLimits(ctrl *gomock.Controller) *MockLimits {
	mock := &MockLimits{ctrl: ctrl}
	mock.recorder = &MockLimitsMockRecorder{mock}
	return mock
}

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

// CanProposeAsset mocks base method.
func (m *MockLimits) CanProposeAsset() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanProposeAsset")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanProposeAsset indicates an expected call of CanProposeAsset.
func (mr *MockLimitsMockRecorder) CanProposeAsset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanProposeAsset", reflect.TypeOf((*MockLimits)(nil).CanProposeAsset))
}

// CanProposeMarket mocks base method.
func (m *MockLimits) CanProposeMarket() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanProposeMarket")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanProposeMarket indicates an expected call of CanProposeMarket.
func (mr *MockLimitsMockRecorder) CanProposeMarket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanProposeMarket", reflect.TypeOf((*MockLimits)(nil).CanProposeMarket))
}

// CanProposePerpsMarket mocks base method.
func (m *MockLimits) CanProposePerpsMarket() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanProposePerpsMarket")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanProposePerpsMarket indicates an expected call of CanProposePerpsMarket.
func (mr *MockLimitsMockRecorder) CanProposePerpsMarket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanProposePerpsMarket", reflect.TypeOf((*MockLimits)(nil).CanProposePerpsMarket))
}

// CanProposeSpotMarket mocks base method.
func (m *MockLimits) CanProposeSpotMarket() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanProposeSpotMarket")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanProposeSpotMarket indicates an expected call of CanProposeSpotMarket.
func (mr *MockLimitsMockRecorder) CanProposeSpotMarket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanProposeSpotMarket", reflect.TypeOf((*MockLimits)(nil).CanProposeSpotMarket))
}

// CanTrade mocks base method.
func (m *MockLimits) CanTrade() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanTrade")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanTrade indicates an expected call of CanTrade.
func (mr *MockLimitsMockRecorder) CanTrade() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanTrade", reflect.TypeOf((*MockLimits)(nil).CanTrade))
}

// CanUseAMMPool mocks base method.
func (m *MockLimits) CanUseAMMPool() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanUseAMMPool")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanUseAMMPool indicates an expected call of CanUseAMMPool.
func (mr *MockLimitsMockRecorder) CanUseAMMPool() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanUseAMMPool", reflect.TypeOf((*MockLimits)(nil).CanUseAMMPool))
}

// MockStakeVerifier is a mock of StakeVerifier interface.
type MockStakeVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockStakeVerifierMockRecorder
}

// MockStakeVerifierMockRecorder is the mock recorder for MockStakeVerifier.
type MockStakeVerifierMockRecorder struct {
	mock *MockStakeVerifier
}

// NewMockStakeVerifier creates a new mock instance.
func NewMockStakeVerifier(ctrl *gomock.Controller) *MockStakeVerifier {
	mock := &MockStakeVerifier{ctrl: ctrl}
	mock.recorder = &MockStakeVerifierMockRecorder{mock}
	return mock
}

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

// ProcessStakeDeposited mocks base method.
func (m *MockStakeVerifier) ProcessStakeDeposited(arg0 context.Context, arg1 *types.StakeDeposited) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessStakeDeposited", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessStakeDeposited indicates an expected call of ProcessStakeDeposited.
func (mr *MockStakeVerifierMockRecorder) ProcessStakeDeposited(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessStakeDeposited", reflect.TypeOf((*MockStakeVerifier)(nil).ProcessStakeDeposited), arg0, arg1)
}

// ProcessStakeRemoved mocks base method.
func (m *MockStakeVerifier) ProcessStakeRemoved(arg0 context.Context, arg1 *types.StakeRemoved) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessStakeRemoved", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessStakeRemoved indicates an expected call of ProcessStakeRemoved.
func (mr *MockStakeVerifierMockRecorder) ProcessStakeRemoved(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessStakeRemoved", reflect.TypeOf((*MockStakeVerifier)(nil).ProcessStakeRemoved), arg0, arg1)
}

// MockStakingAccounts is a mock of StakingAccounts interface.
type MockStakingAccounts struct {
	ctrl     *gomock.Controller
	recorder *MockStakingAccountsMockRecorder
}

// MockStakingAccountsMockRecorder is the mock recorder for MockStakingAccounts.
type MockStakingAccountsMockRecorder struct {
	mock *MockStakingAccounts
}

// NewMockStakingAccounts creates a new mock instance.
func NewMockStakingAccounts(ctrl *gomock.Controller) *MockStakingAccounts {
	mock := &MockStakingAccounts{ctrl: ctrl}
	mock.recorder = &MockStakingAccountsMockRecorder{mock}
	return mock
}

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

// Hash mocks base method.
func (m *MockStakingAccounts) Hash() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hash")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Hash indicates an expected call of Hash.
func (mr *MockStakingAccountsMockRecorder) Hash() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hash", reflect.TypeOf((*MockStakingAccounts)(nil).Hash))
}

// ProcessStakeTotalSupply mocks base method.
func (m *MockStakingAccounts) ProcessStakeTotalSupply(arg0 context.Context, arg1 *types.StakeTotalSupply) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessStakeTotalSupply", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessStakeTotalSupply indicates an expected call of ProcessStakeTotalSupply.
func (mr *MockStakingAccountsMockRecorder) ProcessStakeTotalSupply(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessStakeTotalSupply", reflect.TypeOf((*MockStakingAccounts)(nil).ProcessStakeTotalSupply), arg0, arg1)
}

// MockERC20MultiSigTopology is a mock of ERC20MultiSigTopology interface.
type MockERC20MultiSigTopology struct {
	ctrl     *gomock.Controller
	recorder *MockERC20MultiSigTopologyMockRecorder
}

// MockERC20MultiSigTopologyMockRecorder is the mock recorder for MockERC20MultiSigTopology.
type MockERC20MultiSigTopologyMockRecorder struct {
	mock *MockERC20MultiSigTopology
}

// NewMockERC20MultiSigTopology creates a new mock instance.
func NewMockERC20MultiSigTopology(ctrl *gomock.Controller) *MockERC20MultiSigTopology {
	mock := &MockERC20MultiSigTopology{ctrl: ctrl}
	mock.recorder = &MockERC20MultiSigTopologyMockRecorder{mock}
	return mock
}

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

// ProcessSignerEvent mocks base method.
func (m *MockERC20MultiSigTopology) ProcessSignerEvent(arg0 *types.SignerEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessSignerEvent", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessSignerEvent indicates an expected call of ProcessSignerEvent.
func (mr *MockERC20MultiSigTopologyMockRecorder) ProcessSignerEvent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessSignerEvent", reflect.TypeOf((*MockERC20MultiSigTopology)(nil).ProcessSignerEvent), arg0)
}

// ProcessThresholdEvent mocks base method.
func (m *MockERC20MultiSigTopology) ProcessThresholdEvent(arg0 *types.SignerThresholdSetEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessThresholdEvent", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessThresholdEvent indicates an expected call of ProcessThresholdEvent.
func (mr *MockERC20MultiSigTopologyMockRecorder) ProcessThresholdEvent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessThresholdEvent", reflect.TypeOf((*MockERC20MultiSigTopology)(nil).ProcessThresholdEvent), arg0)
}

// MockCheckpoint is a mock of Checkpoint interface.
type MockCheckpoint struct {
	ctrl     *gomock.Controller
	recorder *MockCheckpointMockRecorder
}

// MockCheckpointMockRecorder is the mock recorder for MockCheckpoint.
type MockCheckpointMockRecorder struct {
	mock *MockCheckpoint
}

// NewMockCheckpoint creates a new mock instance.
func NewMockCheckpoint(ctrl *gomock.Controller) *MockCheckpoint {
	mock := &MockCheckpoint{ctrl: ctrl}
	mock.recorder = &MockCheckpointMockRecorder{mock}
	return mock
}

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

// BalanceCheckpoint mocks base method.
func (m *MockCheckpoint) BalanceCheckpoint(arg0 context.Context) (*types.CheckpointState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalanceCheckpoint", arg0)
	ret0, _ := ret[0].(*types.CheckpointState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BalanceCheckpoint indicates an expected call of BalanceCheckpoint.
func (mr *MockCheckpointMockRecorder) BalanceCheckpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceCheckpoint", reflect.TypeOf((*MockCheckpoint)(nil).BalanceCheckpoint), arg0)
}

// Checkpoint mocks base method.
func (m *MockCheckpoint) Checkpoint(arg0 context.Context, arg1 time.Time) (*types.CheckpointState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Checkpoint", arg0, arg1)
	ret0, _ := ret[0].(*types.CheckpointState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Checkpoint indicates an expected call of Checkpoint.
func (mr *MockCheckpointMockRecorder) Checkpoint(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Checkpoint", reflect.TypeOf((*MockCheckpoint)(nil).Checkpoint), arg0, arg1)
}

// MockBroker is a mock of Broker interface.
type MockBroker struct {
	ctrl     *gomock.Controller
	recorder *MockBrokerMockRecorder
}

// MockBrokerMockRecorder is the mock recorder for MockBroker.
type MockBrokerMockRecorder struct {
	mock *MockBroker
}

// NewMockBroker creates a new mock instance.
func NewMockBroker(ctrl *gomock.Controller) *MockBroker {
	mock := &MockBroker{ctrl: ctrl}
	mock.recorder = &MockBrokerMockRecorder{mock}
	return mock
}

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

// Send mocks base method.
func (m *MockBroker) Send(arg0 events.Event) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Send", arg0)
}

// Send indicates an expected call of Send.
func (mr *MockBrokerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBroker)(nil).Send), arg0)
}

// SetStreaming mocks base method.
func (m *MockBroker) SetStreaming(arg0 bool) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetStreaming", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// SetStreaming indicates an expected call of SetStreaming.
func (mr *MockBrokerMockRecorder) SetStreaming(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStreaming", reflect.TypeOf((*MockBroker)(nil).SetStreaming), arg0)
}

// SocketClient mocks base method.
func (m *MockBroker) SocketClient() broker.SocketClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SocketClient")
	ret0, _ := ret[0].(broker.SocketClient)
	return ret0
}

// SocketClient indicates an expected call of SocketClient.
func (mr *MockBrokerMockRecorder) SocketClient() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SocketClient", reflect.TypeOf((*MockBroker)(nil).SocketClient))
}

// StreamingEnabled mocks base method.
func (m *MockBroker) StreamingEnabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamingEnabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// StreamingEnabled indicates an expected call of StreamingEnabled.
func (mr *MockBrokerMockRecorder) StreamingEnabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamingEnabled", reflect.TypeOf((*MockBroker)(nil).StreamingEnabled))
}

// MockSpamEngine is a mock of SpamEngine interface.
type MockSpamEngine struct {
	ctrl     *gomock.Controller
	recorder *MockSpamEngineMockRecorder
}

// MockSpamEngineMockRecorder is the mock recorder for MockSpamEngine.
type MockSpamEngineMockRecorder struct {
	mock *MockSpamEngine
}

// NewMockSpamEngine creates a new mock instance.
func NewMockSpamEngine(ctrl *gomock.Controller) *MockSpamEngine {
	mock := &MockSpamEngine{ctrl: ctrl}
	mock.recorder = &MockSpamEngineMockRecorder{mock}
	return mock
}

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

// BeginBlock mocks base method.
func (m *MockSpamEngine) BeginBlock(arg0 []abci.Tx) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0)
}

// BeginBlock indicates an expected call of BeginBlock.
func (mr *MockSpamEngineMockRecorder) BeginBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockSpamEngine)(nil).BeginBlock), arg0)
}

// CheckBlockTx mocks base method.
func (m *MockSpamEngine) CheckBlockTx(arg0 abci.Tx) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckBlockTx", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckBlockTx indicates an expected call of CheckBlockTx.
func (mr *MockSpamEngineMockRecorder) CheckBlockTx(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckBlockTx", reflect.TypeOf((*MockSpamEngine)(nil).CheckBlockTx), arg0)
}

// EndPrepareProposal mocks base method.
func (m *MockSpamEngine) EndPrepareProposal() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndPrepareProposal")
}

// EndPrepareProposal indicates an expected call of EndPrepareProposal.
func (mr *MockSpamEngineMockRecorder) EndPrepareProposal() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndPrepareProposal", reflect.TypeOf((*MockSpamEngine)(nil).EndPrepareProposal))
}

// PreBlockAccept mocks base method.
func (m *MockSpamEngine) PreBlockAccept(arg0 abci.Tx) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreBlockAccept", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreBlockAccept indicates an expected call of PreBlockAccept.
func (mr *MockSpamEngineMockRecorder) PreBlockAccept(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreBlockAccept", reflect.TypeOf((*MockSpamEngine)(nil).PreBlockAccept), arg0)
}

// ProcessProposal mocks base method.
func (m *MockSpamEngine) ProcessProposal(arg0 []abci.Tx) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessProposal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ProcessProposal indicates an expected call of ProcessProposal.
func (mr *MockSpamEngineMockRecorder) ProcessProposal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessProposal", reflect.TypeOf((*MockSpamEngine)(nil).ProcessProposal), arg0)
}

// MockPoWEngine is a mock of PoWEngine interface.
type MockPoWEngine struct {
	ctrl     *gomock.Controller
	recorder *MockPoWEngineMockRecorder
}

// MockPoWEngineMockRecorder is the mock recorder for MockPoWEngine.
type MockPoWEngineMockRecorder struct {
	mock *MockPoWEngine
}

// NewMockPoWEngine creates a new mock instance.
func NewMockPoWEngine(ctrl *gomock.Controller) *MockPoWEngine {
	mock := &MockPoWEngine{ctrl: ctrl}
	mock.recorder = &MockPoWEngineMockRecorder{mock}
	return mock
}

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

// BeginBlock mocks base method.
func (m *MockPoWEngine) BeginBlock(arg0 uint64, arg1 string, arg2 []abci.Tx) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0, arg1, arg2)
}

// BeginBlock indicates an expected call of BeginBlock.
func (mr *MockPoWEngineMockRecorder) BeginBlock(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockPoWEngine)(nil).BeginBlock), arg0, arg1, arg2)
}

// BlockData mocks base method.
func (m *MockPoWEngine) BlockData() (uint64, string) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockData")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(string)
	return ret0, ret1
}

// BlockData indicates an expected call of BlockData.
func (mr *MockPoWEngineMockRecorder) BlockData() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockData", reflect.TypeOf((*MockPoWEngine)(nil).BlockData))
}

// CheckBlockTx mocks base method.
func (m *MockPoWEngine) CheckBlockTx(arg0 abci.Tx) (pow.ValidationResult, *uint) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckBlockTx", arg0)
	ret0, _ := ret[0].(pow.ValidationResult)
	ret1, _ := ret[1].(*uint)
	return ret0, ret1
}

// CheckBlockTx indicates an expected call of CheckBlockTx.
func (mr *MockPoWEngineMockRecorder) CheckBlockTx(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckBlockTx", reflect.TypeOf((*MockPoWEngine)(nil).CheckBlockTx), arg0)
}

// CheckTx mocks base method.
func (m *MockPoWEngine) CheckTx(arg0 abci.Tx) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckTx", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckTx indicates an expected call of CheckTx.
func (mr *MockPoWEngineMockRecorder) CheckTx(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTx", reflect.TypeOf((*MockPoWEngine)(nil).CheckTx), arg0)
}

// EndPrepareProposal mocks base method.
func (m *MockPoWEngine) EndPrepareProposal(arg0 []pow.ValidationEntry) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndPrepareProposal", arg0)
}

// EndPrepareProposal indicates an expected call of EndPrepareProposal.
func (mr *MockPoWEngineMockRecorder) EndPrepareProposal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndPrepareProposal", reflect.TypeOf((*MockPoWEngine)(nil).EndPrepareProposal), arg0)
}

// GetSpamStatistics mocks base method.
func (m *MockPoWEngine) GetSpamStatistics(arg0 string) *v1.PoWStatistic {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSpamStatistics", arg0)
	ret0, _ := ret[0].(*v1.PoWStatistic)
	return ret0
}

// GetSpamStatistics indicates an expected call of GetSpamStatistics.
func (mr *MockPoWEngineMockRecorder) GetSpamStatistics(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpamStatistics", reflect.TypeOf((*MockPoWEngine)(nil).GetSpamStatistics), arg0)
}

// IsReady mocks base method.
func (m *MockPoWEngine) IsReady() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsReady")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsReady indicates an expected call of IsReady.
func (mr *MockPoWEngineMockRecorder) IsReady() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsReady", reflect.TypeOf((*MockPoWEngine)(nil).IsReady))
}

// OnCommit mocks base method.
func (m *MockPoWEngine) OnCommit() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnCommit")
}

// OnCommit indicates an expected call of OnCommit.
func (mr *MockPoWEngineMockRecorder) OnCommit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnCommit", reflect.TypeOf((*MockPoWEngine)(nil).OnCommit))
}

// ProcessProposal mocks base method.
func (m *MockPoWEngine) ProcessProposal(arg0 []abci.Tx) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessProposal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ProcessProposal indicates an expected call of ProcessProposal.
func (mr *MockPoWEngineMockRecorder) ProcessProposal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessProposal", reflect.TypeOf((*MockPoWEngine)(nil).ProcessProposal), arg0)
}

// SpamPoWDifficulty mocks base method.
func (m *MockPoWEngine) SpamPoWDifficulty() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpamPoWDifficulty")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// SpamPoWDifficulty indicates an expected call of SpamPoWDifficulty.
func (mr *MockPoWEngineMockRecorder) SpamPoWDifficulty() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpamPoWDifficulty", reflect.TypeOf((*MockPoWEngine)(nil).SpamPoWDifficulty))
}

// SpamPoWHashFunction mocks base method.
func (m *MockPoWEngine) SpamPoWHashFunction() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpamPoWHashFunction")
	ret0, _ := ret[0].(string)
	return ret0
}

// SpamPoWHashFunction indicates an expected call of SpamPoWHashFunction.
func (mr *MockPoWEngineMockRecorder) SpamPoWHashFunction() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpamPoWHashFunction", reflect.TypeOf((*MockPoWEngine)(nil).SpamPoWHashFunction))
}

// SpamPoWIncreasingDifficulty mocks base method.
func (m *MockPoWEngine) SpamPoWIncreasingDifficulty() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpamPoWIncreasingDifficulty")
	ret0, _ := ret[0].(bool)
	return ret0
}

// SpamPoWIncreasingDifficulty indicates an expected call of SpamPoWIncreasingDifficulty.
func (mr *MockPoWEngineMockRecorder) SpamPoWIncreasingDifficulty() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpamPoWIncreasingDifficulty", reflect.TypeOf((*MockPoWEngine)(nil).SpamPoWIncreasingDifficulty))
}

// SpamPoWNumberOfPastBlocks mocks base method.
func (m *MockPoWEngine) SpamPoWNumberOfPastBlocks() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpamPoWNumberOfPastBlocks")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// SpamPoWNumberOfPastBlocks indicates an expected call of SpamPoWNumberOfPastBlocks.
func (mr *MockPoWEngineMockRecorder) SpamPoWNumberOfPastBlocks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpamPoWNumberOfPastBlocks", reflect.TypeOf((*MockPoWEngine)(nil).SpamPoWNumberOfPastBlocks))
}

// SpamPoWNumberOfTxPerBlock mocks base method.
func (m *MockPoWEngine) SpamPoWNumberOfTxPerBlock() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpamPoWNumberOfTxPerBlock")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// SpamPoWNumberOfTxPerBlock indicates an expected call of SpamPoWNumberOfTxPerBlock.
func (mr *MockPoWEngineMockRecorder) SpamPoWNumberOfTxPerBlock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpamPoWNumberOfTxPerBlock", reflect.TypeOf((*MockPoWEngine)(nil).SpamPoWNumberOfTxPerBlock))
}

// MockSnapshotEngine is a mock of SnapshotEngine interface.
type MockSnapshotEngine struct {
	ctrl     *gomock.Controller
	recorder *MockSnapshotEngineMockRecorder
}

// MockSnapshotEngineMockRecorder is the mock recorder for MockSnapshotEngine.
type MockSnapshotEngineMockRecorder struct {
	mock *MockSnapshotEngine
}

// NewMockSnapshotEngine creates a new mock instance.
func NewMockSnapshotEngine(ctrl *gomock.Controller) *MockSnapshotEngine {
	mock := &MockSnapshotEngine{ctrl: ctrl}
	mock.recorder = &MockSnapshotEngineMockRecorder{mock}
	return mock
}

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

// AddProviders mocks base method.
func (m *MockSnapshotEngine) AddProviders(arg0 ...types.StateProvider) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "AddProviders", varargs...)
}

// AddProviders indicates an expected call of AddProviders.
func (mr *MockSnapshotEngineMockRecorder) AddProviders(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProviders", reflect.TypeOf((*MockSnapshotEngine)(nil).AddProviders), arg0...)
}

// HasRestoredStateAlready mocks base method.
func (m *MockSnapshotEngine) HasRestoredStateAlready() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasRestoredStateAlready")
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasRestoredStateAlready indicates an expected call of HasRestoredStateAlready.
func (mr *MockSnapshotEngineMockRecorder) HasRestoredStateAlready() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasRestoredStateAlready", reflect.TypeOf((*MockSnapshotEngine)(nil).HasRestoredStateAlready))
}

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

// HasSnapshots indicates an expected call of HasSnapshots.
func (mr *MockSnapshotEngineMockRecorder) HasSnapshots() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasSnapshots", reflect.TypeOf((*MockSnapshotEngine)(nil).HasSnapshots))
}

// Info mocks base method.
func (m *MockSnapshotEngine) Info() ([]byte, int64, string) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(string)
	return ret0, ret1, ret2
}

// Info indicates an expected call of Info.
func (mr *MockSnapshotEngineMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockSnapshotEngine)(nil).Info))
}

// ListLatestSnapshots mocks base method.
func (m *MockSnapshotEngine) ListLatestSnapshots() ([]*types0.Snapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLatestSnapshots")
	ret0, _ := ret[0].([]*types0.Snapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLatestSnapshots indicates an expected call of ListLatestSnapshots.
func (mr *MockSnapshotEngineMockRecorder) ListLatestSnapshots() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLatestSnapshots", reflect.TypeOf((*MockSnapshotEngine)(nil).ListLatestSnapshots))
}

// ReceiveSnapshot mocks base method.
func (m *MockSnapshotEngine) ReceiveSnapshot(arg0 *types.Snapshot) types0.ResponseOfferSnapshot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveSnapshot", arg0)
	ret0, _ := ret[0].(types0.ResponseOfferSnapshot)
	return ret0
}

// ReceiveSnapshot indicates an expected call of ReceiveSnapshot.
func (mr *MockSnapshotEngineMockRecorder) ReceiveSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveSnapshot", reflect.TypeOf((*MockSnapshotEngine)(nil).ReceiveSnapshot), arg0)
}

// ReceiveSnapshotChunk mocks base method.
func (m *MockSnapshotEngine) ReceiveSnapshotChunk(arg0 context.Context, arg1 *types.RawChunk, arg2 string) types0.ResponseApplySnapshotChunk {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveSnapshotChunk", arg0, arg1, arg2)
	ret0, _ := ret[0].(types0.ResponseApplySnapshotChunk)
	return ret0
}

// ReceiveSnapshotChunk indicates an expected call of ReceiveSnapshotChunk.
func (mr *MockSnapshotEngineMockRecorder) ReceiveSnapshotChunk(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveSnapshotChunk", reflect.TypeOf((*MockSnapshotEngine)(nil).ReceiveSnapshotChunk), arg0, arg1, arg2)
}

// RetrieveSnapshotChunk mocks base method.
func (m *MockSnapshotEngine) RetrieveSnapshotChunk(arg0 uint64, arg1, arg2 uint32) (*types.RawChunk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetrieveSnapshotChunk", arg0, arg1, arg2)
	ret0, _ := ret[0].(*types.RawChunk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RetrieveSnapshotChunk indicates an expected call of RetrieveSnapshotChunk.
func (mr *MockSnapshotEngineMockRecorder) RetrieveSnapshotChunk(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveSnapshotChunk", reflect.TypeOf((*MockSnapshotEngine)(nil).RetrieveSnapshotChunk), arg0, arg1, arg2)
}

// Snapshot mocks base method.
func (m *MockSnapshotEngine) Snapshot(arg0 context.Context) ([]byte, snapshot.DoneCh, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Snapshot", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(snapshot.DoneCh)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Snapshot indicates an expected call of Snapshot.
func (mr *MockSnapshotEngineMockRecorder) Snapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Snapshot", reflect.TypeOf((*MockSnapshotEngine)(nil).Snapshot), arg0)
}

// SnapshotDump mocks base method.
func (m *MockSnapshotEngine) SnapshotDump(arg0 context.Context, arg1 string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SnapshotDump", arg0, arg1)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SnapshotDump indicates an expected call of SnapshotDump.
func (mr *MockSnapshotEngineMockRecorder) SnapshotDump(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotDump", reflect.TypeOf((*MockSnapshotEngine)(nil).SnapshotDump), arg0, arg1)
}

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

// SnapshotNow indicates an expected call of SnapshotNow.
func (mr *MockSnapshotEngineMockRecorder) SnapshotNow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotNow", reflect.TypeOf((*MockSnapshotEngine)(nil).SnapshotNow), arg0)
}

// MockStateVarEngine is a mock of StateVarEngine interface.
type MockStateVarEngine struct {
	ctrl     *gomock.Controller
	recorder *MockStateVarEngineMockRecorder
}

// MockStateVarEngineMockRecorder is the mock recorder for MockStateVarEngine.
type MockStateVarEngineMockRecorder struct {
	mock *MockStateVarEngine
}

// NewMockStateVarEngine creates a new mock instance.
func NewMockStateVarEngine(ctrl *gomock.Controller) *MockStateVarEngine {
	mock := &MockStateVarEngine{ctrl: ctrl}
	mock.recorder = &MockStateVarEngineMockRecorder{mock}
	return mock
}

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

// OnBlockEnd mocks base method.
func (m *MockStateVarEngine) OnBlockEnd(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnBlockEnd", arg0)
}

// OnBlockEnd indicates an expected call of OnBlockEnd.
func (mr *MockStateVarEngineMockRecorder) OnBlockEnd(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnBlockEnd", reflect.TypeOf((*MockStateVarEngine)(nil).OnBlockEnd), arg0)
}

// ProposedValueReceived mocks base method.
func (m *MockStateVarEngine) ProposedValueReceived(arg0 context.Context, arg1, arg2, arg3 string, arg4 *statevar.KeyValueBundle) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProposedValueReceived", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProposedValueReceived indicates an expected call of ProposedValueReceived.
func (mr *MockStateVarEngineMockRecorder) ProposedValueReceived(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposedValueReceived", reflect.TypeOf((*MockStateVarEngine)(nil).ProposedValueReceived), arg0, arg1, arg2, arg3, arg4)
}

// MockTeamsEngine is a mock of TeamsEngine interface.
type MockTeamsEngine struct {
	ctrl     *gomock.Controller
	recorder *MockTeamsEngineMockRecorder
}

// MockTeamsEngineMockRecorder is the mock recorder for MockTeamsEngine.
type MockTeamsEngineMockRecorder struct {
	mock *MockTeamsEngine
}

// NewMockTeamsEngine creates a new mock instance.
func NewMockTeamsEngine(ctrl *gomock.Controller) *MockTeamsEngine {
	mock := &MockTeamsEngine{ctrl: ctrl}
	mock.recorder = &MockTeamsEngineMockRecorder{mock}
	return mock
}

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

// CreateTeam mocks base method.
func (m *MockTeamsEngine) CreateTeam(arg0 context.Context, arg1 types.PartyID, arg2 types.TeamID, arg3 *v10.CreateReferralSet_Team) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTeam", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateTeam indicates an expected call of CreateTeam.
func (mr *MockTeamsEngineMockRecorder) CreateTeam(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTeam", reflect.TypeOf((*MockTeamsEngine)(nil).CreateTeam), arg0, arg1, arg2, arg3)
}

// JoinTeam mocks base method.
func (m *MockTeamsEngine) JoinTeam(arg0 context.Context, arg1 types.PartyID, arg2 *v10.JoinTeam) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinTeam", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// JoinTeam indicates an expected call of JoinTeam.
func (mr *MockTeamsEngineMockRecorder) JoinTeam(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinTeam", reflect.TypeOf((*MockTeamsEngine)(nil).JoinTeam), arg0, arg1, arg2)
}

// TeamExists mocks base method.
func (m *MockTeamsEngine) TeamExists(arg0 types.TeamID) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TeamExists", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// TeamExists indicates an expected call of TeamExists.
func (mr *MockTeamsEngineMockRecorder) TeamExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TeamExists", reflect.TypeOf((*MockTeamsEngine)(nil).TeamExists), arg0)
}

// UpdateTeam mocks base method.
func (m *MockTeamsEngine) UpdateTeam(arg0 context.Context, arg1 types.PartyID, arg2 types.TeamID, arg3 *v10.UpdateReferralSet_Team) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTeam", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTeam indicates an expected call of UpdateTeam.
func (mr *MockTeamsEngineMockRecorder) UpdateTeam(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTeam", reflect.TypeOf((*MockTeamsEngine)(nil).UpdateTeam), arg0, arg1, arg2, arg3)
}

// MockReferralProgram is a mock of ReferralProgram interface.
type MockReferralProgram struct {
	ctrl     *gomock.Controller
	recorder *MockReferralProgramMockRecorder
}

// MockReferralProgramMockRecorder is the mock recorder for MockReferralProgram.
type MockReferralProgramMockRecorder struct {
	mock *MockReferralProgram
}

// NewMockReferralProgram creates a new mock instance.
func NewMockReferralProgram(ctrl *gomock.Controller) *MockReferralProgram {
	mock := &MockReferralProgram{ctrl: ctrl}
	mock.recorder = &MockReferralProgramMockRecorder{mock}
	return mock
}

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

// ApplyReferralCode mocks base method.
func (m *MockReferralProgram) ApplyReferralCode(arg0 context.Context, arg1 types.PartyID, arg2 types.ReferralSetID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyReferralCode", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyReferralCode indicates an expected call of ApplyReferralCode.
func (mr *MockReferralProgramMockRecorder) ApplyReferralCode(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyReferralCode", reflect.TypeOf((*MockReferralProgram)(nil).ApplyReferralCode), arg0, arg1, arg2)
}

// CheckSufficientBalanceForApplyReferralCode mocks base method.
func (m *MockReferralProgram) CheckSufficientBalanceForApplyReferralCode(arg0 types.PartyID, arg1 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckSufficientBalanceForApplyReferralCode", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckSufficientBalanceForApplyReferralCode indicates an expected call of CheckSufficientBalanceForApplyReferralCode.
func (mr *MockReferralProgramMockRecorder) CheckSufficientBalanceForApplyReferralCode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSufficientBalanceForApplyReferralCode", reflect.TypeOf((*MockReferralProgram)(nil).CheckSufficientBalanceForApplyReferralCode), arg0, arg1)
}

// CheckSufficientBalanceForCreateOrUpdateReferralSet mocks base method.
func (m *MockReferralProgram) CheckSufficientBalanceForCreateOrUpdateReferralSet(arg0 types.PartyID, arg1 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckSufficientBalanceForCreateOrUpdateReferralSet", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckSufficientBalanceForCreateOrUpdateReferralSet indicates an expected call of CheckSufficientBalanceForCreateOrUpdateReferralSet.
func (mr *MockReferralProgramMockRecorder) CheckSufficientBalanceForCreateOrUpdateReferralSet(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSufficientBalanceForCreateOrUpdateReferralSet", reflect.TypeOf((*MockReferralProgram)(nil).CheckSufficientBalanceForCreateOrUpdateReferralSet), arg0, arg1)
}

// CreateReferralSet mocks base method.
func (m *MockReferralProgram) CreateReferralSet(arg0 context.Context, arg1 types.PartyID, arg2 types.ReferralSetID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReferralSet", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateReferralSet indicates an expected call of CreateReferralSet.
func (mr *MockReferralProgramMockRecorder) CreateReferralSet(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReferralSet", reflect.TypeOf((*MockReferralProgram)(nil).CreateReferralSet), arg0, arg1, arg2)
}

// PartyOwnsReferralSet mocks base method.
func (m *MockReferralProgram) PartyOwnsReferralSet(arg0 types.PartyID, arg1 types.ReferralSetID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PartyOwnsReferralSet", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PartyOwnsReferralSet indicates an expected call of PartyOwnsReferralSet.
func (mr *MockReferralProgramMockRecorder) PartyOwnsReferralSet(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PartyOwnsReferralSet", reflect.TypeOf((*MockReferralProgram)(nil).PartyOwnsReferralSet), arg0, arg1)
}

// UpdateProgram mocks base method.
func (m *MockReferralProgram) UpdateProgram(arg0 *types.ReferralProgram) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateProgram", arg0)
}

// UpdateProgram indicates an expected call of UpdateProgram.
func (mr *MockReferralProgramMockRecorder) UpdateProgram(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProgram", reflect.TypeOf((*MockReferralProgram)(nil).UpdateProgram), arg0)
}

// MockVolumeDiscountProgram is a mock of VolumeDiscountProgram interface.
type MockVolumeDiscountProgram struct {
	ctrl     *gomock.Controller
	recorder *MockVolumeDiscountProgramMockRecorder
}

// MockVolumeDiscountProgramMockRecorder is the mock recorder for MockVolumeDiscountProgram.
type MockVolumeDiscountProgramMockRecorder struct {
	mock *MockVolumeDiscountProgram
}

// NewMockVolumeDiscountProgram creates a new mock instance.
func NewMockVolumeDiscountProgram(ctrl *gomock.Controller) *MockVolumeDiscountProgram {
	mock := &MockVolumeDiscountProgram{ctrl: ctrl}
	mock.recorder = &MockVolumeDiscountProgramMockRecorder{mock}
	return mock
}

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

// UpdateProgram mocks base method.
func (m *MockVolumeDiscountProgram) UpdateProgram(arg0 *types.VolumeDiscountProgram) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateProgram", arg0)
}

// UpdateProgram indicates an expected call of UpdateProgram.
func (mr *MockVolumeDiscountProgramMockRecorder) UpdateProgram(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProgram", reflect.TypeOf((*MockVolumeDiscountProgram)(nil).UpdateProgram), arg0)
}

// MockVolumeRebateProgram is a mock of VolumeRebateProgram interface.
type MockVolumeRebateProgram struct {
	ctrl     *gomock.Controller
	recorder *MockVolumeRebateProgramMockRecorder
}

// MockVolumeRebateProgramMockRecorder is the mock recorder for MockVolumeRebateProgram.
type MockVolumeRebateProgramMockRecorder struct {
	mock *MockVolumeRebateProgram
}

// NewMockVolumeRebateProgram creates a new mock instance.
func NewMockVolumeRebateProgram(ctrl *gomock.Controller) *MockVolumeRebateProgram {
	mock := &MockVolumeRebateProgram{ctrl: ctrl}
	mock.recorder = &MockVolumeRebateProgramMockRecorder{mock}
	return mock
}

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

// UpdateProgram mocks base method.
func (m *MockVolumeRebateProgram) UpdateProgram(arg0 *types.VolumeRebateProgram) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateProgram", arg0)
}

// UpdateProgram indicates an expected call of UpdateProgram.
func (mr *MockVolumeRebateProgramMockRecorder) UpdateProgram(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProgram", reflect.TypeOf((*MockVolumeRebateProgram)(nil).UpdateProgram), arg0)
}

// MockBlockchainClient is a mock of BlockchainClient interface.
type MockBlockchainClient struct {
	ctrl     *gomock.Controller
	recorder *MockBlockchainClientMockRecorder
}

// MockBlockchainClientMockRecorder is the mock recorder for MockBlockchainClient.
type MockBlockchainClientMockRecorder struct {
	mock *MockBlockchainClient
}

// NewMockBlockchainClient creates a new mock instance.
func NewMockBlockchainClient(ctrl *gomock.Controller) *MockBlockchainClient {
	mock := &MockBlockchainClient{ctrl: ctrl}
	mock.recorder = &MockBlockchainClientMockRecorder{mock}
	return mock
}

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

// MaxMempoolSize mocks base method.
func (m *MockBlockchainClient) MaxMempoolSize() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaxMempoolSize")
	ret0, _ := ret[0].(int64)
	return ret0
}

// MaxMempoolSize indicates an expected call of MaxMempoolSize.
func (mr *MockBlockchainClientMockRecorder) MaxMempoolSize() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxMempoolSize", reflect.TypeOf((*MockBlockchainClient)(nil).MaxMempoolSize))
}

// Validators mocks base method.
func (m *MockBlockchainClient) Validators(arg0 *int64) ([]*types1.Validator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Validators", arg0)
	ret0, _ := ret[0].([]*types1.Validator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Validators indicates an expected call of Validators.
func (mr *MockBlockchainClientMockRecorder) Validators(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validators", reflect.TypeOf((*MockBlockchainClient)(nil).Validators), arg0)
}

// MockProtocolUpgradeService is a mock of ProtocolUpgradeService interface.
type MockProtocolUpgradeService struct {
	ctrl     *gomock.Controller
	recorder *MockProtocolUpgradeServiceMockRecorder
}

// MockProtocolUpgradeServiceMockRecorder is the mock recorder for MockProtocolUpgradeService.
type MockProtocolUpgradeServiceMockRecorder struct {
	mock *MockProtocolUpgradeService
}

// NewMockProtocolUpgradeService creates a new mock instance.
func NewMockProtocolUpgradeService(ctrl *gomock.Controller) *MockProtocolUpgradeService {
	mock := &MockProtocolUpgradeService{ctrl: ctrl}
	mock.recorder = &MockProtocolUpgradeServiceMockRecorder{mock}
	return mock
}

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

// BeginBlock mocks base method.
func (m *MockProtocolUpgradeService) BeginBlock(arg0 context.Context, arg1 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0, arg1)
}

// BeginBlock indicates an expected call of BeginBlock.
func (mr *MockProtocolUpgradeServiceMockRecorder) BeginBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockProtocolUpgradeService)(nil).BeginBlock), arg0, arg1)
}

// Cleanup mocks base method.
func (m *MockProtocolUpgradeService) Cleanup(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Cleanup", arg0)
}

// Cleanup indicates an expected call of Cleanup.
func (mr *MockProtocolUpgradeServiceMockRecorder) Cleanup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockProtocolUpgradeService)(nil).Cleanup), arg0)
}

// CoreReadyForUpgrade mocks base method.
func (m *MockProtocolUpgradeService) CoreReadyForUpgrade() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CoreReadyForUpgrade")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CoreReadyForUpgrade indicates an expected call of CoreReadyForUpgrade.
func (mr *MockProtocolUpgradeServiceMockRecorder) CoreReadyForUpgrade() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoreReadyForUpgrade", reflect.TypeOf((*MockProtocolUpgradeService)(nil).CoreReadyForUpgrade))
}

// GetUpgradeStatus mocks base method.
func (m *MockProtocolUpgradeService) GetUpgradeStatus() types.UpgradeStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpgradeStatus")
	ret0, _ := ret[0].(types.UpgradeStatus)
	return ret0
}

// GetUpgradeStatus indicates an expected call of GetUpgradeStatus.
func (mr *MockProtocolUpgradeServiceMockRecorder) GetUpgradeStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpgradeStatus", reflect.TypeOf((*MockProtocolUpgradeService)(nil).GetUpgradeStatus))
}

// IsValidProposal mocks base method.
func (m *MockProtocolUpgradeService) IsValidProposal(arg0 context.Context, arg1 string, arg2 uint64, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsValidProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// IsValidProposal indicates an expected call of IsValidProposal.
func (mr *MockProtocolUpgradeServiceMockRecorder) IsValidProposal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsValidProposal", reflect.TypeOf((*MockProtocolUpgradeService)(nil).IsValidProposal), arg0, arg1, arg2, arg3)
}

// SetCoreReadyForUpgrade mocks base method.
func (m *MockProtocolUpgradeService) SetCoreReadyForUpgrade() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCoreReadyForUpgrade")
}

// SetCoreReadyForUpgrade indicates an expected call of SetCoreReadyForUpgrade.
func (mr *MockProtocolUpgradeServiceMockRecorder) SetCoreReadyForUpgrade() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCoreReadyForUpgrade", reflect.TypeOf((*MockProtocolUpgradeService)(nil).SetCoreReadyForUpgrade))
}

// SetReadyForUpgrade mocks base method.
func (m *MockProtocolUpgradeService) SetReadyForUpgrade() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetReadyForUpgrade")
}

// SetReadyForUpgrade indicates an expected call of SetReadyForUpgrade.
func (mr *MockProtocolUpgradeServiceMockRecorder) SetReadyForUpgrade() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadyForUpgrade", reflect.TypeOf((*MockProtocolUpgradeService)(nil).SetReadyForUpgrade))
}

// TimeForUpgrade mocks base method.
func (m *MockProtocolUpgradeService) TimeForUpgrade() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimeForUpgrade")
	ret0, _ := ret[0].(bool)
	return ret0
}

// TimeForUpgrade indicates an expected call of TimeForUpgrade.
func (mr *MockProtocolUpgradeServiceMockRecorder) TimeForUpgrade() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeForUpgrade", reflect.TypeOf((*MockProtocolUpgradeService)(nil).TimeForUpgrade))
}

// UpgradeProposal mocks base method.
func (m *MockProtocolUpgradeService) UpgradeProposal(arg0 context.Context, arg1 string, arg2 uint64, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpgradeProposal", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpgradeProposal indicates an expected call of UpgradeProposal.
func (mr *MockProtocolUpgradeServiceMockRecorder) UpgradeProposal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeProposal", reflect.TypeOf((*MockProtocolUpgradeService)(nil).UpgradeProposal), arg0, arg1, arg2, arg3)
}

// MockEthCallEngine is a mock of EthCallEngine interface.
type MockEthCallEngine struct {
	ctrl     *gomock.Controller
	recorder *MockEthCallEngineMockRecorder
}

// MockEthCallEngineMockRecorder is the mock recorder for MockEthCallEngine.
type MockEthCallEngineMockRecorder struct {
	mock *MockEthCallEngine
}

// NewMockEthCallEngine creates a new mock instance.
func NewMockEthCallEngine(ctrl *gomock.Controller) *MockEthCallEngine {
	mock := &MockEthCallEngine{ctrl: ctrl}
	mock.recorder = &MockEthCallEngineMockRecorder{mock}
	return mock
}

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

// Start mocks base method.
func (m *MockEthCallEngine) Start() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start")
}

// Start indicates an expected call of Start.
func (mr *MockEthCallEngineMockRecorder) Start() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockEthCallEngine)(nil).Start))
}

// MockBalanceChecker is a mock of BalanceChecker interface.
type MockBalanceChecker struct {
	ctrl     *gomock.Controller
	recorder *MockBalanceCheckerMockRecorder
}

// MockBalanceCheckerMockRecorder is the mock recorder for MockBalanceChecker.
type MockBalanceCheckerMockRecorder struct {
	mock *MockBalanceChecker
}

// NewMockBalanceChecker creates a new mock instance.
func NewMockBalanceChecker(ctrl *gomock.Controller) *MockBalanceChecker {
	mock := &MockBalanceChecker{ctrl: ctrl}
	mock.recorder = &MockBalanceCheckerMockRecorder{mock}
	return mock
}

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

// BeginBlock mocks base method.
func (m *MockBalanceChecker) BeginBlock(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", arg0)
}

// BeginBlock indicates an expected call of BeginBlock.
func (mr *MockBalanceCheckerMockRecorder) BeginBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockBalanceChecker)(nil).BeginBlock), arg0)
}

// GetPartyBalance mocks base method.
func (m *MockBalanceChecker) GetPartyBalance(arg0 string) *num.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPartyBalance", arg0)
	ret0, _ := ret[0].(*num.Uint)
	return ret0
}

// GetPartyBalance indicates an expected call of GetPartyBalance.
func (mr *MockBalanceCheckerMockRecorder) GetPartyBalance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPartyBalance", reflect.TypeOf((*MockBalanceChecker)(nil).GetPartyBalance), arg0)
}

// MockPartiesEngine is a mock of PartiesEngine interface.
type MockPartiesEngine struct {
	ctrl     *gomock.Controller
	recorder *MockPartiesEngineMockRecorder
}

// MockPartiesEngineMockRecorder is the mock recorder for MockPartiesEngine.
type MockPartiesEngineMockRecorder struct {
	mock *MockPartiesEngine
}

// NewMockPartiesEngine creates a new mock instance.
func NewMockPartiesEngine(ctrl *gomock.Controller) *MockPartiesEngine {
	mock := &MockPartiesEngine{ctrl: ctrl}
	mock.recorder = &MockPartiesEngineMockRecorder{mock}
	return mock
}

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

// CheckSufficientBalanceToUpdateProfile mocks base method.
func (m *MockPartiesEngine) CheckSufficientBalanceToUpdateProfile(arg0 types.PartyID, arg1 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckSufficientBalanceToUpdateProfile", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckSufficientBalanceToUpdateProfile indicates an expected call of CheckSufficientBalanceToUpdateProfile.
func (mr *MockPartiesEngineMockRecorder) CheckSufficientBalanceToUpdateProfile(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSufficientBalanceToUpdateProfile", reflect.TypeOf((*MockPartiesEngine)(nil).CheckSufficientBalanceToUpdateProfile), arg0, arg1)
}

// UpdateProfile mocks base method.
func (m *MockPartiesEngine) UpdateProfile(arg0 context.Context, arg1 types.PartyID, arg2 *v10.UpdatePartyProfile) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProfile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProfile indicates an expected call of UpdateProfile.
func (mr *MockPartiesEngineMockRecorder) UpdateProfile(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProfile", reflect.TypeOf((*MockPartiesEngine)(nil).UpdateProfile), arg0, arg1, arg2)
}

// MockTxCache is a mock of TxCache interface.
type MockTxCache struct {
	ctrl     *gomock.Controller
	recorder *MockTxCacheMockRecorder
}

// MockTxCacheMockRecorder is the mock recorder for MockTxCache.
type MockTxCacheMockRecorder struct {
	mock *MockTxCache
}

// NewMockTxCache creates a new mock instance.
func NewMockTxCache(ctrl *gomock.Controller) *MockTxCache {
	mock := &MockTxCache{ctrl: ctrl}
	mock.recorder = &MockTxCacheMockRecorder{mock}
	return mock
}

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

// GetRawTxs mocks base method.
func (m *MockTxCache) GetRawTxs(arg0 uint64) [][]byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRawTxs", arg0)
	ret0, _ := ret[0].([][]byte)
	return ret0
}

// GetRawTxs indicates an expected call of GetRawTxs.
func (mr *MockTxCacheMockRecorder) GetRawTxs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawTxs", reflect.TypeOf((*MockTxCache)(nil).GetRawTxs), arg0)
}

// IsDelayRequired mocks base method.
func (m *MockTxCache) IsDelayRequired(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDelayRequired", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsDelayRequired indicates an expected call of IsDelayRequired.
func (mr *MockTxCacheMockRecorder) IsDelayRequired(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDelayRequired", reflect.TypeOf((*MockTxCache)(nil).IsDelayRequired), arg0)
}

// IsDelayRequiredAnyMarket mocks base method.
func (m *MockTxCache) IsDelayRequiredAnyMarket() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDelayRequiredAnyMarket")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsDelayRequiredAnyMarket indicates an expected call of IsDelayRequiredAnyMarket.
func (mr *MockTxCacheMockRecorder) IsDelayRequiredAnyMarket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDelayRequiredAnyMarket", reflect.TypeOf((*MockTxCache)(nil).IsDelayRequiredAnyMarket))
}

// IsTxInCache mocks base method.
func (m *MockTxCache) IsTxInCache(arg0 []byte) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsTxInCache", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsTxInCache indicates an expected call of IsTxInCache.
func (mr *MockTxCacheMockRecorder) IsTxInCache(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTxInCache", reflect.TypeOf((*MockTxCache)(nil).IsTxInCache), arg0)
}

// NewDelayedTransaction mocks base method.
func (m *MockTxCache) NewDelayedTransaction(arg0 context.Context, arg1 [][]byte, arg2 uint64) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDelayedTransaction", arg0, arg1, arg2)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// NewDelayedTransaction indicates an expected call of NewDelayedTransaction.
func (mr *MockTxCacheMockRecorder) NewDelayedTransaction(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDelayedTransaction", reflect.TypeOf((*MockTxCache)(nil).NewDelayedTransaction), arg0, arg1, arg2)
}

// SetRawTxs mocks base method.
func (m *MockTxCache) SetRawTxs(arg0 [][]byte, arg1 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRawTxs", arg0, arg1)
}

// SetRawTxs indicates an expected call of SetRawTxs.
func (mr *MockTxCacheMockRecorder) SetRawTxs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRawTxs", reflect.TypeOf((*MockTxCache)(nil).SetRawTxs), arg0, arg1)
}

// MockEthereumOracleVerifier is a mock of EthereumOracleVerifier interface.
type MockEthereumOracleVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockEthereumOracleVerifierMockRecorder
}

// MockEthereumOracleVerifierMockRecorder is the mock recorder for MockEthereumOracleVerifier.
type MockEthereumOracleVerifierMockRecorder struct {
	mock *MockEthereumOracleVerifier
}

// NewMockEthereumOracleVerifier creates a new mock instance.
func NewMockEthereumOracleVerifier(ctrl *gomock.Controller) *MockEthereumOracleVerifier {
	mock := &MockEthereumOracleVerifier{ctrl: ctrl}
	mock.recorder = &MockEthereumOracleVerifierMockRecorder{mock}
	return mock
}

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

// ProcessEthereumContractCallResult mocks base method.
func (m *MockEthereumOracleVerifier) ProcessEthereumContractCallResult(arg0 ethcall.ContractCallEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessEthereumContractCallResult", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessEthereumContractCallResult indicates an expected call of ProcessEthereumContractCallResult.
func (mr *MockEthereumOracleVerifierMockRecorder) ProcessEthereumContractCallResult(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessEthereumContractCallResult", reflect.TypeOf((*MockEthereumOracleVerifier)(nil).ProcessEthereumContractCallResult), arg0)
}

// MockCodec is a mock of Codec interface.
type MockCodec struct {
	ctrl     *gomock.Controller
	recorder *MockCodecMockRecorder
}

// MockCodecMockRecorder is the mock recorder for MockCodec.
type MockCodecMockRecorder struct {
	mock *MockCodec
}

// NewMockCodec creates a new mock instance.
func NewMockCodec(ctrl *gomock.Controller) *MockCodec {
	mock := &MockCodec{ctrl: ctrl}
	mock.recorder = &MockCodecMockRecorder{mock}
	return mock
}

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

// Decode mocks base method.
func (m *MockCodec) Decode(arg0 []byte, arg1 string) (abci.Tx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decode", arg0, arg1)
	ret0, _ := ret[0].(abci.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Decode indicates an expected call of Decode.
func (mr *MockCodecMockRecorder) Decode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockCodec)(nil).Decode), arg0, arg1)
}