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

package mocks

import (
	queue "github.com/33cn/chain33/queue"
	mock "github.com/stretchr/testify/mock"

	types "github.com/33cn/chain33/types"
)

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

// AddBlacklist provides a mock function with given fields: req
func (_m *QueueProtocolAPI) AddBlacklist(req *types.BlackPeer) (*types.Reply, error) {
	ret := _m.Called(req)

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.BlackPeer) (*types.Reply, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*types.BlackPeer) *types.Reply); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.BlackPeer) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddPushSubscribe provides a mock function with given fields: param
func (_m *QueueProtocolAPI) AddPushSubscribe(param *types.PushSubscribeReq) (*types.ReplySubscribePush, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplySubscribePush
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.PushSubscribeReq) (*types.ReplySubscribePush, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.PushSubscribeReq) *types.ReplySubscribePush); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplySubscribePush)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.PushSubscribeReq) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Close provides a mock function with given fields:
func (_m *QueueProtocolAPI) Close() {
	_m.Called()
}

// ClosePeer provides a mock function with given fields: in
func (_m *QueueProtocolAPI) ClosePeer(in *types.SetPeer) (*types.Reply, error) {
	ret := _m.Called(in)

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.SetPeer) (*types.Reply, error)); ok {
		return rf(in)
	}
	if rf, ok := ret.Get(0).(func(*types.SetPeer) *types.Reply); ok {
		r0 = rf(in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.SetPeer) error); ok {
		r1 = rf(in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloseQueue provides a mock function with given fields:
func (_m *QueueProtocolAPI) CloseQueue() (*types.Reply, error) {
	ret := _m.Called()

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.Reply, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.Reply); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

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

	return r0, r1
}

// DelBlacklist provides a mock function with given fields: req
func (_m *QueueProtocolAPI) DelBlacklist(req *types.BlackPeer) (*types.Reply, error) {
	ret := _m.Called(req)

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.BlackPeer) (*types.Reply, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*types.BlackPeer) *types.Reply); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.BlackPeer) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DialPeer provides a mock function with given fields: in
func (_m *QueueProtocolAPI) DialPeer(in *types.SetPeer) (*types.Reply, error) {
	ret := _m.Called(in)

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.SetPeer) (*types.Reply, error)); ok {
		return rf(in)
	}
	if rf, ok := ret.Get(0).(func(*types.SetPeer) *types.Reply); ok {
		r0 = rf(in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.SetPeer) error); ok {
		r1 = rf(in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExecWallet provides a mock function with given fields: param
func (_m *QueueProtocolAPI) ExecWallet(param *types.ChainExecutor) (types.Message, error) {
	ret := _m.Called(param)

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

	var r0 types.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ChainExecutor) (types.Message, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ChainExecutor) types.Message); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ChainExecutor) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExecWalletFunc provides a mock function with given fields: driver, funcname, param
func (_m *QueueProtocolAPI) ExecWalletFunc(driver string, funcname string, param types.Message) (types.Message, error) {
	ret := _m.Called(driver, funcname, param)

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

	var r0 types.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, types.Message) (types.Message, error)); ok {
		return rf(driver, funcname, param)
	}
	if rf, ok := ret.Get(0).(func(string, string, types.Message) types.Message); ok {
		r0 = rf(driver, funcname, param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, types.Message) error); ok {
		r1 = rf(driver, funcname, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAddrOverview provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetAddrOverview(param *types.ReqAddr) (*types.AddrOverview, error) {
	ret := _m.Called(param)

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

	var r0 *types.AddrOverview
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqAddr) (*types.AddrOverview, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqAddr) *types.AddrOverview); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.AddrOverview)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqAddr) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlockByHashes provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetBlockByHashes(param *types.ReqHashes) (*types.BlockDetails, error) {
	ret := _m.Called(param)

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

	var r0 *types.BlockDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHashes) (*types.BlockDetails, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHashes) *types.BlockDetails); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.BlockDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHashes) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlockBySeq provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetBlockBySeq(param *types.Int64) (*types.BlockSeq, error) {
	ret := _m.Called(param)

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

	var r0 *types.BlockSeq
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.Int64) (*types.BlockSeq, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.Int64) *types.BlockSeq); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.BlockSeq)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.Int64) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlockHash provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetBlockHash(param *types.ReqInt) (*types.ReplyHash, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHash
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqInt) (*types.ReplyHash, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqInt) *types.ReplyHash); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHash)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqInt) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlockOverview provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetBlockOverview(param *types.ReqHash) (*types.BlockOverview, error) {
	ret := _m.Called(param)

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

	var r0 *types.BlockOverview
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHash) (*types.BlockOverview, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.BlockOverview); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.BlockOverview)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlockSequences provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetBlockSequences(param *types.ReqBlocks) (*types.BlockSequences, error) {
	ret := _m.Called(param)

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

	var r0 *types.BlockSequences
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) (*types.BlockSequences, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) *types.BlockSequences); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.BlockSequences)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqBlocks) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetBlocks provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetBlocks(param *types.ReqBlocks) (*types.BlockDetails, error) {
	ret := _m.Called(param)

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

	var r0 *types.BlockDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) (*types.BlockDetails, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) *types.BlockDetails); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.BlockDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqBlocks) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetConfig provides a mock function with given fields:
func (_m *QueueProtocolAPI) GetConfig() *types.Chain33Config {
	ret := _m.Called()

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

	var r0 *types.Chain33Config
	if rf, ok := ret.Get(0).(func() *types.Chain33Config); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Chain33Config)
		}
	}

	return r0
}

// GetFinalizedBlock provides a mock function with given fields:
func (_m *QueueProtocolAPI) GetFinalizedBlock() (*types.SnowChoice, error) {
	ret := _m.Called()

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

	var r0 *types.SnowChoice
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.SnowChoice, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.SnowChoice); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.SnowChoice)
		}
	}

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

	return r0, r1
}

// GetHeaders provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetHeaders(param *types.ReqBlocks) (*types.Headers, error) {
	ret := _m.Called(param)

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

	var r0 *types.Headers
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) (*types.Headers, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqBlocks) *types.Headers); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Headers)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqBlocks) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHighestBlockNum provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetHighestBlockNum(param *types.ReqNil) (*types.ReplyBlockHeight, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyBlockHeight
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqNil) (*types.ReplyBlockHeight, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqNil) *types.ReplyBlockHeight); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyBlockHeight)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqNil) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLastBlockMainSequence provides a mock function with given fields:
func (_m *QueueProtocolAPI) GetLastBlockMainSequence() (*types.Int64, error) {
	ret := _m.Called()

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

	var r0 *types.Int64
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.Int64, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.Int64); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Int64)
		}
	}

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

	return r0, r1
}

// GetLastBlockSequence provides a mock function with given fields:
func (_m *QueueProtocolAPI) GetLastBlockSequence() (*types.Int64, error) {
	ret := _m.Called()

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

	var r0 *types.Int64
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.Int64, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.Int64); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Int64)
		}
	}

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

	return r0, r1
}

// GetLastHeader provides a mock function with given fields:
func (_m *QueueProtocolAPI) GetLastHeader() (*types.Header, error) {
	ret := _m.Called()

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

	var r0 *types.Header
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.Header, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.Header); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Header)
		}
	}

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

	return r0, r1
}

// GetLastMempool provides a mock function with given fields:
func (_m *QueueProtocolAPI) GetLastMempool() (*types.ReplyTxList, error) {
	ret := _m.Called()

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

	var r0 *types.ReplyTxList
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.ReplyTxList, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.ReplyTxList); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyTxList)
		}
	}

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

	return r0, r1
}

// GetMainSequenceByHash provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetMainSequenceByHash(param *types.ReqHash) (*types.Int64, error) {
	ret := _m.Called(param)

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

	var r0 *types.Int64
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHash) (*types.Int64, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.Int64); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Int64)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetMempool provides a mock function with given fields: req
func (_m *QueueProtocolAPI) GetMempool(req *types.ReqGetMempool) (*types.ReplyTxList, error) {
	ret := _m.Called(req)

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

	var r0 *types.ReplyTxList
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqGetMempool) (*types.ReplyTxList, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqGetMempool) *types.ReplyTxList); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyTxList)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqGetMempool) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetNetInfo provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetNetInfo(param *types.P2PGetNetInfoReq) (*types.NodeNetInfo, error) {
	ret := _m.Called(param)

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

	var r0 *types.NodeNetInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.P2PGetNetInfoReq) (*types.NodeNetInfo, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.P2PGetNetInfoReq) *types.NodeNetInfo); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.NodeNetInfo)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.P2PGetNetInfoReq) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetParaTxByHeight provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetParaTxByHeight(param *types.ReqParaTxByHeight) (*types.ParaTxDetails, error) {
	ret := _m.Called(param)

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

	var r0 *types.ParaTxDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqParaTxByHeight) (*types.ParaTxDetails, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqParaTxByHeight) *types.ParaTxDetails); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ParaTxDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqParaTxByHeight) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetParaTxByTitle provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetParaTxByTitle(param *types.ReqParaTxByTitle) (*types.ParaTxDetails, error) {
	ret := _m.Called(param)

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

	var r0 *types.ParaTxDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqParaTxByTitle) (*types.ParaTxDetails, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqParaTxByTitle) *types.ParaTxDetails); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ParaTxDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqParaTxByTitle) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetProperFee provides a mock function with given fields: req
func (_m *QueueProtocolAPI) GetProperFee(req *types.ReqProperFee) (*types.ReplyProperFee, error) {
	ret := _m.Called(req)

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

	var r0 *types.ReplyProperFee
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqProperFee) (*types.ReplyProperFee, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqProperFee) *types.ReplyProperFee); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyProperFee)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqProperFee) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPushSeqLastNum provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetPushSeqLastNum(param *types.ReqString) (*types.Int64, error) {
	ret := _m.Called(param)

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

	var r0 *types.Int64
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqString) (*types.Int64, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqString) *types.Int64); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Int64)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqString) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSequenceByHash provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetSequenceByHash(param *types.ReqHash) (*types.Int64, error) {
	ret := _m.Called(param)

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

	var r0 *types.Int64
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHash) (*types.Int64, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.Int64); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Int64)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransactionByAddr provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetTransactionByAddr(param *types.ReqAddr) (*types.ReplyTxInfos, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyTxInfos
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqAddr) (*types.ReplyTxInfos, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqAddr) *types.ReplyTxInfos); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyTxInfos)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqAddr) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransactionByHash provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetTransactionByHash(param *types.ReqHashes) (*types.TransactionDetails, error) {
	ret := _m.Called(param)

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

	var r0 *types.TransactionDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHashes) (*types.TransactionDetails, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHashes) *types.TransactionDetails); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.TransactionDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHashes) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTxList provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetTxList(param *types.TxHashList) (*types.ReplyTxList, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyTxList
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.TxHashList) (*types.ReplyTxList, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.TxHashList) *types.ReplyTxList); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyTxList)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.TxHashList) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTxListByAddr provides a mock function with given fields: param
func (_m *QueueProtocolAPI) GetTxListByAddr(param *types.ReqAddrs) (*types.TransactionDetails, error) {
	ret := _m.Called(param)

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

	var r0 *types.TransactionDetails
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqAddrs) (*types.TransactionDetails, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqAddrs) *types.TransactionDetails); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.TransactionDetails)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqAddrs) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// IsNtpClockSync provides a mock function with given fields:
func (_m *QueueProtocolAPI) IsNtpClockSync() (*types.Reply, error) {
	ret := _m.Called()

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.Reply, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.Reply); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

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

	return r0, r1
}

// IsSync provides a mock function with given fields:
func (_m *QueueProtocolAPI) IsSync() (*types.Reply, error) {
	ret := _m.Called()

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.Reply, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.Reply); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

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

	return r0, r1
}

// ListPushes provides a mock function with given fields:
func (_m *QueueProtocolAPI) ListPushes() (*types.PushSubscribes, error) {
	ret := _m.Called()

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

	var r0 *types.PushSubscribes
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.PushSubscribes, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.PushSubscribes); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.PushSubscribes)
		}
	}

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

	return r0, r1
}

// LoadParaTxByTitle provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LoadParaTxByTitle(param *types.ReqHeightByTitle) (*types.ReplyHeightByTitle, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHeightByTitle
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHeightByTitle) (*types.ReplyHeightByTitle, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHeightByTitle) *types.ReplyHeightByTitle); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHeightByTitle)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHeightByTitle) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LocalBegin provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalBegin(param *types.Int64) error {
	ret := _m.Called(param)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.Int64) error); ok {
		r0 = rf(param)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// LocalClose provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalClose(param *types.Int64) error {
	ret := _m.Called(param)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.Int64) error); ok {
		r0 = rf(param)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// LocalCommit provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalCommit(param *types.Int64) error {
	ret := _m.Called(param)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.Int64) error); ok {
		r0 = rf(param)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// LocalGet provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalGet(param *types.LocalDBGet) (*types.LocalReplyValue, error) {
	ret := _m.Called(param)

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

	var r0 *types.LocalReplyValue
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.LocalDBGet) (*types.LocalReplyValue, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.LocalDBGet) *types.LocalReplyValue); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.LocalReplyValue)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.LocalDBGet) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LocalList provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalList(param *types.LocalDBList) (*types.LocalReplyValue, error) {
	ret := _m.Called(param)

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

	var r0 *types.LocalReplyValue
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.LocalDBList) (*types.LocalReplyValue, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.LocalDBList) *types.LocalReplyValue); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.LocalReplyValue)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.LocalDBList) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LocalNew provides a mock function with given fields: readOnly
func (_m *QueueProtocolAPI) LocalNew(readOnly bool) (*types.Int64, error) {
	ret := _m.Called(readOnly)

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

	var r0 *types.Int64
	var r1 error
	if rf, ok := ret.Get(0).(func(bool) (*types.Int64, error)); ok {
		return rf(readOnly)
	}
	if rf, ok := ret.Get(0).(func(bool) *types.Int64); ok {
		r0 = rf(readOnly)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Int64)
		}
	}

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

	return r0, r1
}

// LocalRollback provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalRollback(param *types.Int64) error {
	ret := _m.Called(param)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.Int64) error); ok {
		r0 = rf(param)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// LocalSet provides a mock function with given fields: param
func (_m *QueueProtocolAPI) LocalSet(param *types.LocalDBSet) error {
	ret := _m.Called(param)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.LocalDBSet) error); ok {
		r0 = rf(param)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// NetProtocols provides a mock function with given fields: _a0
func (_m *QueueProtocolAPI) NetProtocols(_a0 *types.ReqNil) (*types.NetProtocolInfos, error) {
	ret := _m.Called(_a0)

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

	var r0 *types.NetProtocolInfos
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqNil) (*types.NetProtocolInfos, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqNil) *types.NetProtocolInfos); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.NetProtocolInfos)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqNil) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NewMessage provides a mock function with given fields: topic, msgid, data
func (_m *QueueProtocolAPI) NewMessage(topic string, msgid int64, data interface{}) *queue.Message {
	ret := _m.Called(topic, msgid, data)

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

	var r0 *queue.Message
	if rf, ok := ret.Get(0).(func(string, int64, interface{}) *queue.Message); ok {
		r0 = rf(topic, msgid, data)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queue.Message)
		}
	}

	return r0
}

// Notify provides a mock function with given fields: topic, ty, data
func (_m *QueueProtocolAPI) Notify(topic string, ty int64, data interface{}) (*queue.Message, error) {
	ret := _m.Called(topic, ty, data)

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

	var r0 *queue.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(string, int64, interface{}) (*queue.Message, error)); ok {
		return rf(topic, ty, data)
	}
	if rf, ok := ret.Get(0).(func(string, int64, interface{}) *queue.Message); ok {
		r0 = rf(topic, ty, data)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queue.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(string, int64, interface{}) error); ok {
		r1 = rf(topic, ty, data)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PeerInfo provides a mock function with given fields: param
func (_m *QueueProtocolAPI) PeerInfo(param *types.P2PGetPeerReq) (*types.PeerList, error) {
	ret := _m.Called(param)

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

	var r0 *types.PeerList
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.P2PGetPeerReq) (*types.PeerList, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.P2PGetPeerReq) *types.PeerList); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.PeerList)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.P2PGetPeerReq) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Query provides a mock function with given fields: driver, funcname, param
func (_m *QueueProtocolAPI) Query(driver string, funcname string, param types.Message) (types.Message, error) {
	ret := _m.Called(driver, funcname, param)

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

	var r0 types.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, types.Message) (types.Message, error)); ok {
		return rf(driver, funcname, param)
	}
	if rf, ok := ret.Get(0).(func(string, string, types.Message) types.Message); ok {
		r0 = rf(driver, funcname, param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, types.Message) error); ok {
		r1 = rf(driver, funcname, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QueryChain provides a mock function with given fields: param
func (_m *QueueProtocolAPI) QueryChain(param *types.ChainExecutor) (types.Message, error) {
	ret := _m.Called(param)

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

	var r0 types.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ChainExecutor) (types.Message, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ChainExecutor) types.Message); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ChainExecutor) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QueryConsensus provides a mock function with given fields: param
func (_m *QueueProtocolAPI) QueryConsensus(param *types.ChainExecutor) (types.Message, error) {
	ret := _m.Called(param)

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

	var r0 types.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ChainExecutor) (types.Message, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ChainExecutor) types.Message); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ChainExecutor) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QueryConsensusFunc provides a mock function with given fields: driver, funcname, param
func (_m *QueueProtocolAPI) QueryConsensusFunc(driver string, funcname string, param types.Message) (types.Message, error) {
	ret := _m.Called(driver, funcname, param)

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

	var r0 types.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, types.Message) (types.Message, error)); ok {
		return rf(driver, funcname, param)
	}
	if rf, ok := ret.Get(0).(func(string, string, types.Message) types.Message); ok {
		r0 = rf(driver, funcname, param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, types.Message) error); ok {
		r1 = rf(driver, funcname, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QueryTx provides a mock function with given fields: param
func (_m *QueueProtocolAPI) QueryTx(param *types.ReqHash) (*types.TransactionDetail, error) {
	ret := _m.Called(param)

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

	var r0 *types.TransactionDetail
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHash) (*types.TransactionDetail, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.TransactionDetail); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.TransactionDetail)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveTxsByHashList provides a mock function with given fields: hashList
func (_m *QueueProtocolAPI) RemoveTxsByHashList(hashList *types.TxHashList) error {
	ret := _m.Called(hashList)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.TxHashList) error); ok {
		r0 = rf(hashList)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SendDelayTx provides a mock function with given fields: param, waitReply
func (_m *QueueProtocolAPI) SendDelayTx(param *types.DelayTx, waitReply bool) (*types.Reply, error) {
	ret := _m.Called(param, waitReply)

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.DelayTx, bool) (*types.Reply, error)); ok {
		return rf(param, waitReply)
	}
	if rf, ok := ret.Get(0).(func(*types.DelayTx, bool) *types.Reply); ok {
		r0 = rf(param, waitReply)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.DelayTx, bool) error); ok {
		r1 = rf(param, waitReply)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SendTx provides a mock function with given fields: param
func (_m *QueueProtocolAPI) SendTx(param *types.Transaction) (*types.Reply, error) {
	ret := _m.Called(param)

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

	var r0 *types.Reply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.Transaction) (*types.Reply, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.Transaction) *types.Reply); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Reply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.Transaction) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ShowBlacklist provides a mock function with given fields: req
func (_m *QueueProtocolAPI) ShowBlacklist(req *types.ReqNil) (*types.Blacklist, error) {
	ret := _m.Called(req)

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

	var r0 *types.Blacklist
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqNil) (*types.Blacklist, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqNil) *types.Blacklist); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Blacklist)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqNil) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreCommit provides a mock function with given fields: param
func (_m *QueueProtocolAPI) StoreCommit(param *types.ReqHash) (*types.ReplyHash, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHash
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHash) (*types.ReplyHash, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.ReplyHash); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHash)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreDel provides a mock function with given fields: param
func (_m *QueueProtocolAPI) StoreDel(param *types.StoreDel) (*types.ReplyHash, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHash
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.StoreDel) (*types.ReplyHash, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.StoreDel) *types.ReplyHash); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHash)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.StoreDel) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreGet provides a mock function with given fields: _a0
func (_m *QueueProtocolAPI) StoreGet(_a0 *types.StoreGet) (*types.StoreReplyValue, error) {
	ret := _m.Called(_a0)

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

	var r0 *types.StoreReplyValue
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.StoreGet) (*types.StoreReplyValue, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*types.StoreGet) *types.StoreReplyValue); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.StoreReplyValue)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.StoreGet) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreGetTotalCoins provides a mock function with given fields: _a0
func (_m *QueueProtocolAPI) StoreGetTotalCoins(_a0 *types.IterateRangeByStateHash) (*types.ReplyGetTotalCoins, error) {
	ret := _m.Called(_a0)

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

	var r0 *types.ReplyGetTotalCoins
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.IterateRangeByStateHash) (*types.ReplyGetTotalCoins, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*types.IterateRangeByStateHash) *types.ReplyGetTotalCoins); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyGetTotalCoins)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.IterateRangeByStateHash) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreList provides a mock function with given fields: param
func (_m *QueueProtocolAPI) StoreList(param *types.StoreList) (*types.StoreListReply, error) {
	ret := _m.Called(param)

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

	var r0 *types.StoreListReply
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.StoreList) (*types.StoreListReply, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.StoreList) *types.StoreListReply); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.StoreListReply)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.StoreList) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreMemSet provides a mock function with given fields: param
func (_m *QueueProtocolAPI) StoreMemSet(param *types.StoreSetWithSync) (*types.ReplyHash, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHash
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.StoreSetWithSync) (*types.ReplyHash, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.StoreSetWithSync) *types.ReplyHash); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHash)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.StoreSetWithSync) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreRollback provides a mock function with given fields: param
func (_m *QueueProtocolAPI) StoreRollback(param *types.ReqHash) (*types.ReplyHash, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHash
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.ReqHash) (*types.ReplyHash, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.ReqHash) *types.ReplyHash); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHash)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.ReqHash) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StoreSet provides a mock function with given fields: param
func (_m *QueueProtocolAPI) StoreSet(param *types.StoreSetWithSync) (*types.ReplyHash, error) {
	ret := _m.Called(param)

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

	var r0 *types.ReplyHash
	var r1 error
	if rf, ok := ret.Get(0).(func(*types.StoreSetWithSync) (*types.ReplyHash, error)); ok {
		return rf(param)
	}
	if rf, ok := ret.Get(0).(func(*types.StoreSetWithSync) *types.ReplyHash); ok {
		r0 = rf(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ReplyHash)
		}
	}

	if rf, ok := ret.Get(1).(func(*types.StoreSetWithSync) error); ok {
		r1 = rf(param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Version provides a mock function with given fields:
func (_m *QueueProtocolAPI) Version() (*types.VersionInfo, error) {
	ret := _m.Called()

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

	var r0 *types.VersionInfo
	var r1 error
	if rf, ok := ret.Get(0).(func() (*types.VersionInfo, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() *types.VersionInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.VersionInfo)
		}
	}

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

	return r0, r1
}

// NewQueueProtocolAPI creates a new instance of QueueProtocolAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewQueueProtocolAPI(t interface {
	mock.TestingT
	Cleanup(func())
}) *QueueProtocolAPI {
	mock := &QueueProtocolAPI{}
	mock.Mock.Test(t)

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

	return mock
}
