interface_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./interface.go

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

import (
	rpc "github.com/Conflux-Chain/go-conflux-sdk/rpc"
	types "github.com/Conflux-Chain/go-conflux-sdk/types"
	hexutil "github.com/ethereum/go-ethereum/common/hexutil"
	gomock "github.com/golang/mock/gomock"
	big "math/big"
	http "net/http"
	reflect "reflect"
	time "time"
)

// MockHTTPRequester is a mock of HTTPRequester interface
type MockHTTPRequester struct {
	ctrl     *gomock.Controller
	recorder *MockHTTPRequesterMockRecorder
}

// MockHTTPRequesterMockRecorder is the mock recorder for MockHTTPRequester
type MockHTTPRequesterMockRecorder struct {
	mock *MockHTTPRequester
}

// NewMockHTTPRequester creates a new mock instance
func NewMockHTTPRequester(ctrl *gomock.Controller) *MockHTTPRequester {
	mock := &MockHTTPRequester{ctrl: ctrl}
	mock.recorder = &MockHTTPRequesterMockRecorder{mock}
	return mock
}

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

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

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

// MockContractor is a mock of Contractor interface
type MockContractor struct {
	ctrl     *gomock.Controller
	recorder *MockContractorMockRecorder
}

// MockContractorMockRecorder is the mock recorder for MockContractor
type MockContractorMockRecorder struct {
	mock *MockContractor
}

// NewMockContractor creates a new mock instance
func NewMockContractor(ctrl *gomock.Controller) *MockContractor {
	mock := &MockContractor{ctrl: ctrl}
	mock.recorder = &MockContractorMockRecorder{mock}
	return mock
}

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

// GetData mocks base method
func (m *MockContractor) GetData(method string, args ...interface{}) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetData", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetData indicates an expected call of GetData
func (mr *MockContractorMockRecorder) GetData(method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockContractor)(nil).GetData), varargs...)
}

// Call mocks base method
func (m *MockContractor) Call(option *types.ContractMethodCallOption, resultPtr interface{}, method string, args ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{option, resultPtr, method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Call", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Call indicates an expected call of Call
func (mr *MockContractorMockRecorder) Call(option, resultPtr, method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{option, resultPtr, method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockContractor)(nil).Call), varargs...)
}

// SendTransaction mocks base method
func (m *MockContractor) SendTransaction(option *types.ContractMethodSendOption, method string, args ...interface{}) (*types.Hash, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{option, method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendTransaction", varargs...)
	ret0, _ := ret[0].(*types.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendTransaction indicates an expected call of SendTransaction
func (mr *MockContractorMockRecorder) SendTransaction(option, method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{option, method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockContractor)(nil).SendTransaction), varargs...)
}

// DecodeEvent mocks base method
func (m *MockContractor) DecodeEvent(out interface{}, event string, log types.Log) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodeEvent", out, event, log)
	ret0, _ := ret[0].(error)
	return ret0
}

// DecodeEvent indicates an expected call of DecodeEvent
func (mr *MockContractorMockRecorder) DecodeEvent(out, event, log interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeEvent", reflect.TypeOf((*MockContractor)(nil).DecodeEvent), out, event, log)
}

// MockClientOperator is a mock of ClientOperator interface
type MockClientOperator struct {
	ctrl     *gomock.Controller
	recorder *MockClientOperatorMockRecorder
}

// MockClientOperatorMockRecorder is the mock recorder for MockClientOperator
type MockClientOperatorMockRecorder struct {
	mock *MockClientOperator
}

// NewMockClientOperator creates a new mock instance
func NewMockClientOperator(ctrl *gomock.Controller) *MockClientOperator {
	mock := &MockClientOperator{ctrl: ctrl}
	mock.recorder = &MockClientOperatorMockRecorder{mock}
	return mock
}

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

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

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

// GetEpochNumber mocks base method
func (m *MockClientOperator) GetEpochNumber(epoch ...*types.Epoch) (*big.Int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range epoch {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEpochNumber", varargs...)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEpochNumber indicates an expected call of GetEpochNumber
func (mr *MockClientOperatorMockRecorder) GetEpochNumber(epoch ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochNumber", reflect.TypeOf((*MockClientOperator)(nil).GetEpochNumber), epoch...)
}

// GetBalance mocks base method
func (m *MockClientOperator) GetBalance(address types.Address, epoch ...*types.Epoch) (*big.Int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{address}
	for _, a := range epoch {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBalance", varargs...)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBalance indicates an expected call of GetBalance
func (mr *MockClientOperatorMockRecorder) GetBalance(address interface{}, epoch ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{address}, epoch...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockClientOperator)(nil).GetBalance), varargs...)
}

// GetCode mocks base method
func (m *MockClientOperator) GetCode(address types.Address, epoch ...*types.Epoch) (string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{address}
	for _, a := range epoch {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCode", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCode indicates an expected call of GetCode
func (mr *MockClientOperatorMockRecorder) GetCode(address interface{}, epoch ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{address}, epoch...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCode", reflect.TypeOf((*MockClientOperator)(nil).GetCode), varargs...)
}

// GetBlockSummaryByHash mocks base method
func (m *MockClientOperator) GetBlockSummaryByHash(blockHash types.Hash) (*types.BlockSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockSummaryByHash", blockHash)
	ret0, _ := ret[0].(*types.BlockSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockSummaryByHash indicates an expected call of GetBlockSummaryByHash
func (mr *MockClientOperatorMockRecorder) GetBlockSummaryByHash(blockHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockSummaryByHash", reflect.TypeOf((*MockClientOperator)(nil).GetBlockSummaryByHash), blockHash)
}

// GetBlockByHash mocks base method
func (m *MockClientOperator) GetBlockByHash(blockHash types.Hash) (*types.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockByHash", blockHash)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockByHash indicates an expected call of GetBlockByHash
func (mr *MockClientOperatorMockRecorder) GetBlockByHash(blockHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHash", reflect.TypeOf((*MockClientOperator)(nil).GetBlockByHash), blockHash)
}

// GetBlockSummaryByEpoch mocks base method
func (m *MockClientOperator) GetBlockSummaryByEpoch(epoch *types.Epoch) (*types.BlockSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockSummaryByEpoch", epoch)
	ret0, _ := ret[0].(*types.BlockSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockSummaryByEpoch indicates an expected call of GetBlockSummaryByEpoch
func (mr *MockClientOperatorMockRecorder) GetBlockSummaryByEpoch(epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockSummaryByEpoch", reflect.TypeOf((*MockClientOperator)(nil).GetBlockSummaryByEpoch), epoch)
}

// GetBlockByEpoch mocks base method
func (m *MockClientOperator) GetBlockByEpoch(epoch *types.Epoch) (*types.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockByEpoch", epoch)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockByEpoch indicates an expected call of GetBlockByEpoch
func (mr *MockClientOperatorMockRecorder) GetBlockByEpoch(epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByEpoch", reflect.TypeOf((*MockClientOperator)(nil).GetBlockByEpoch), epoch)
}

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

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

// GetRawBlockConfirmationRisk mocks base method
func (m *MockClientOperator) GetRawBlockConfirmationRisk(blockhash types.Hash) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRawBlockConfirmationRisk", blockhash)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRawBlockConfirmationRisk indicates an expected call of GetRawBlockConfirmationRisk
func (mr *MockClientOperatorMockRecorder) GetRawBlockConfirmationRisk(blockhash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawBlockConfirmationRisk", reflect.TypeOf((*MockClientOperator)(nil).GetRawBlockConfirmationRisk), blockhash)
}

// GetBlockConfirmationRisk mocks base method
func (m *MockClientOperator) GetBlockConfirmationRisk(blockHash types.Hash) (*big.Float, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockConfirmationRisk", blockHash)
	ret0, _ := ret[0].(*big.Float)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockConfirmationRisk indicates an expected call of GetBlockConfirmationRisk
func (mr *MockClientOperatorMockRecorder) GetBlockConfirmationRisk(blockHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockConfirmationRisk", reflect.TypeOf((*MockClientOperator)(nil).GetBlockConfirmationRisk), blockHash)
}

// SendRawTransaction mocks base method
func (m *MockClientOperator) SendRawTransaction(rawData []byte) (types.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendRawTransaction", rawData)
	ret0, _ := ret[0].(types.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendRawTransaction indicates an expected call of SendRawTransaction
func (mr *MockClientOperatorMockRecorder) SendRawTransaction(rawData interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRawTransaction", reflect.TypeOf((*MockClientOperator)(nil).SendRawTransaction), rawData)
}

// SendTransaction mocks base method
func (m *MockClientOperator) SendTransaction(tx *types.UnsignedTransaction) (types.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendTransaction", tx)
	ret0, _ := ret[0].(types.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendTransaction indicates an expected call of SendTransaction
func (mr *MockClientOperatorMockRecorder) SendTransaction(tx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockClientOperator)(nil).SendTransaction), tx)
}

// SetAccountManager mocks base method
func (m *MockClientOperator) SetAccountManager(accountManager AccountManagerOperator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAccountManager", accountManager)
}

// SetAccountManager indicates an expected call of SetAccountManager
func (mr *MockClientOperatorMockRecorder) SetAccountManager(accountManager interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccountManager", reflect.TypeOf((*MockClientOperator)(nil).SetAccountManager), accountManager)
}

// SignEncodedTransactionAndSend mocks base method
func (m *MockClientOperator) SignEncodedTransactionAndSend(encodedTx []byte, v byte, r, s []byte) (*types.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignEncodedTransactionAndSend", encodedTx, v, r, s)
	ret0, _ := ret[0].(*types.Transaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignEncodedTransactionAndSend indicates an expected call of SignEncodedTransactionAndSend
func (mr *MockClientOperatorMockRecorder) SignEncodedTransactionAndSend(encodedTx, v, r, s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignEncodedTransactionAndSend", reflect.TypeOf((*MockClientOperator)(nil).SignEncodedTransactionAndSend), encodedTx, v, r, s)
}

// Call mocks base method
func (m *MockClientOperator) Call(request types.CallRequest, epoch *types.Epoch) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Call", request, epoch)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Call indicates an expected call of Call
func (mr *MockClientOperatorMockRecorder) Call(request, epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockClientOperator)(nil).Call), request, epoch)
}

// CallRPC mocks base method
func (m *MockClientOperator) CallRPC(result interface{}, method string, args ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{result, method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CallRPC", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CallRPC indicates an expected call of CallRPC
func (mr *MockClientOperatorMockRecorder) CallRPC(result, method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{result, method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallRPC", reflect.TypeOf((*MockClientOperator)(nil).CallRPC), varargs...)
}

// BatchCallRPC mocks base method
func (m *MockClientOperator) BatchCallRPC(b []rpc.BatchElem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCallRPC", b)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCallRPC indicates an expected call of BatchCallRPC
func (mr *MockClientOperatorMockRecorder) BatchCallRPC(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallRPC", reflect.TypeOf((*MockClientOperator)(nil).BatchCallRPC), b)
}

// GetLogs mocks base method
func (m *MockClientOperator) GetLogs(filter types.LogFilter) ([]types.Log, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs", filter)
	ret0, _ := ret[0].([]types.Log)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogs indicates an expected call of GetLogs
func (mr *MockClientOperatorMockRecorder) GetLogs(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockClientOperator)(nil).GetLogs), filter)
}

// GetTransactionByHash mocks base method
func (m *MockClientOperator) GetTransactionByHash(txHash types.Hash) (*types.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransactionByHash", txHash)
	ret0, _ := ret[0].(*types.Transaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransactionByHash indicates an expected call of GetTransactionByHash
func (mr *MockClientOperatorMockRecorder) GetTransactionByHash(txHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionByHash", reflect.TypeOf((*MockClientOperator)(nil).GetTransactionByHash), txHash)
}

// EstimateGasAndCollateral mocks base method
func (m *MockClientOperator) EstimateGasAndCollateral(request types.CallRequest) (*types.Estimate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateGasAndCollateral", request)
	ret0, _ := ret[0].(*types.Estimate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimateGasAndCollateral indicates an expected call of EstimateGasAndCollateral
func (mr *MockClientOperatorMockRecorder) EstimateGasAndCollateral(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGasAndCollateral", reflect.TypeOf((*MockClientOperator)(nil).EstimateGasAndCollateral), request)
}

// GetBlocksByEpoch mocks base method
func (m *MockClientOperator) GetBlocksByEpoch(epoch *types.Epoch) ([]types.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlocksByEpoch", epoch)
	ret0, _ := ret[0].([]types.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlocksByEpoch indicates an expected call of GetBlocksByEpoch
func (mr *MockClientOperatorMockRecorder) GetBlocksByEpoch(epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlocksByEpoch", reflect.TypeOf((*MockClientOperator)(nil).GetBlocksByEpoch), epoch)
}

// GetTransactionReceipt mocks base method
func (m *MockClientOperator) GetTransactionReceipt(txHash types.Hash) (*types.TransactionReceipt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransactionReceipt", txHash)
	ret0, _ := ret[0].(*types.TransactionReceipt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransactionReceipt indicates an expected call of GetTransactionReceipt
func (mr *MockClientOperatorMockRecorder) GetTransactionReceipt(txHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionReceipt", reflect.TypeOf((*MockClientOperator)(nil).GetTransactionReceipt), txHash)
}

// CreateUnsignedTransaction mocks base method
func (m *MockClientOperator) CreateUnsignedTransaction(from, to types.Address, amount *hexutil.Big, data []byte) (*types.UnsignedTransaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUnsignedTransaction", from, to, amount, data)
	ret0, _ := ret[0].(*types.UnsignedTransaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUnsignedTransaction indicates an expected call of CreateUnsignedTransaction
func (mr *MockClientOperatorMockRecorder) CreateUnsignedTransaction(from, to, amount, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUnsignedTransaction", reflect.TypeOf((*MockClientOperator)(nil).CreateUnsignedTransaction), from, to, amount, data)
}

// ApplyUnsignedTransactionDefault mocks base method
func (m *MockClientOperator) ApplyUnsignedTransactionDefault(tx *types.UnsignedTransaction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyUnsignedTransactionDefault", tx)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyUnsignedTransactionDefault indicates an expected call of ApplyUnsignedTransactionDefault
func (mr *MockClientOperatorMockRecorder) ApplyUnsignedTransactionDefault(tx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyUnsignedTransactionDefault", reflect.TypeOf((*MockClientOperator)(nil).ApplyUnsignedTransactionDefault), tx)
}

// Debug mocks base method
func (m *MockClientOperator) Debug(method string, args ...interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Debug", varargs...)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Debug indicates an expected call of Debug
func (mr *MockClientOperatorMockRecorder) Debug(method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockClientOperator)(nil).Debug), varargs...)
}

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

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

// GetContract mocks base method
func (m *MockClientOperator) GetContract(abiJSON []byte, deployedAt *types.Address) (*Contract, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContract", abiJSON, deployedAt)
	ret0, _ := ret[0].(*Contract)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContract indicates an expected call of GetContract
func (mr *MockClientOperatorMockRecorder) GetContract(abiJSON, deployedAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContract", reflect.TypeOf((*MockClientOperator)(nil).GetContract), abiJSON, deployedAt)
}

// DeployContract mocks base method
func (m *MockClientOperator) DeployContract(option *types.ContractDeployOption, abiJSON, bytecode []byte, constroctorParams ...interface{}) *ContractDeployResult {
	m.ctrl.T.Helper()
	varargs := []interface{}{option, abiJSON, bytecode}
	for _, a := range constroctorParams {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeployContract", varargs...)
	ret0, _ := ret[0].(*ContractDeployResult)
	return ret0
}

// DeployContract indicates an expected call of DeployContract
func (mr *MockClientOperatorMockRecorder) DeployContract(option, abiJSON, bytecode interface{}, constroctorParams ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{option, abiJSON, bytecode}, constroctorParams...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployContract", reflect.TypeOf((*MockClientOperator)(nil).DeployContract), varargs...)
}

// BatchGetTxByHashes mocks base method
func (m *MockClientOperator) BatchGetTxByHashes(txhashes []types.Hash) (map[types.Hash]*types.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetTxByHashes", txhashes)
	ret0, _ := ret[0].(map[types.Hash]*types.Transaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetTxByHashes indicates an expected call of BatchGetTxByHashes
func (mr *MockClientOperatorMockRecorder) BatchGetTxByHashes(txhashes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetTxByHashes", reflect.TypeOf((*MockClientOperator)(nil).BatchGetTxByHashes), txhashes)
}

// BatchGetBlockConfirmationRisk mocks base method
func (m *MockClientOperator) BatchGetBlockConfirmationRisk(blockhashes []types.Hash) (map[types.Hash]*big.Float, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetBlockConfirmationRisk", blockhashes)
	ret0, _ := ret[0].(map[types.Hash]*big.Float)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetBlockConfirmationRisk indicates an expected call of BatchGetBlockConfirmationRisk
func (mr *MockClientOperatorMockRecorder) BatchGetBlockConfirmationRisk(blockhashes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetBlockConfirmationRisk", reflect.TypeOf((*MockClientOperator)(nil).BatchGetBlockConfirmationRisk), blockhashes)
}

// BatchGetRawBlockConfirmationRisk mocks base method
func (m *MockClientOperator) BatchGetRawBlockConfirmationRisk(blockhashes []types.Hash) (map[types.Hash]*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetRawBlockConfirmationRisk", blockhashes)
	ret0, _ := ret[0].(map[types.Hash]*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetRawBlockConfirmationRisk indicates an expected call of BatchGetRawBlockConfirmationRisk
func (mr *MockClientOperatorMockRecorder) BatchGetRawBlockConfirmationRisk(blockhashes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetRawBlockConfirmationRisk", reflect.TypeOf((*MockClientOperator)(nil).BatchGetRawBlockConfirmationRisk), blockhashes)
}

// BatchGetBlockSummarys mocks base method
func (m *MockClientOperator) BatchGetBlockSummarys(blockhashes []types.Hash) (map[types.Hash]*types.BlockSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetBlockSummarys", blockhashes)
	ret0, _ := ret[0].(map[types.Hash]*types.BlockSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetBlockSummarys indicates an expected call of BatchGetBlockSummarys
func (mr *MockClientOperatorMockRecorder) BatchGetBlockSummarys(blockhashes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetBlockSummarys", reflect.TypeOf((*MockClientOperator)(nil).BatchGetBlockSummarys), blockhashes)
}

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

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

// MockAccountManagerOperator is a mock of AccountManagerOperator interface
type MockAccountManagerOperator struct {
	ctrl     *gomock.Controller
	recorder *MockAccountManagerOperatorMockRecorder
}

// MockAccountManagerOperatorMockRecorder is the mock recorder for MockAccountManagerOperator
type MockAccountManagerOperatorMockRecorder struct {
	mock *MockAccountManagerOperator
}

// NewMockAccountManagerOperator creates a new mock instance
func NewMockAccountManagerOperator(ctrl *gomock.Controller) *MockAccountManagerOperator {
	mock := &MockAccountManagerOperator{ctrl: ctrl}
	mock.recorder = &MockAccountManagerOperatorMockRecorder{mock}
	return mock
}

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

// Create mocks base method
func (m *MockAccountManagerOperator) Create(passphrase string) (types.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", passphrase)
	ret0, _ := ret[0].(types.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create
func (mr *MockAccountManagerOperatorMockRecorder) Create(passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAccountManagerOperator)(nil).Create), passphrase)
}

// Import mocks base method
func (m *MockAccountManagerOperator) Import(keyFile, passphrase, newPassphrase string) (types.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Import", keyFile, passphrase, newPassphrase)
	ret0, _ := ret[0].(types.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Import indicates an expected call of Import
func (mr *MockAccountManagerOperatorMockRecorder) Import(keyFile, passphrase, newPassphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Import", reflect.TypeOf((*MockAccountManagerOperator)(nil).Import), keyFile, passphrase, newPassphrase)
}

// Delete mocks base method
func (m *MockAccountManagerOperator) Delete(address types.Address, passphrase string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", address, passphrase)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockAccountManagerOperatorMockRecorder) Delete(address, passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAccountManagerOperator)(nil).Delete), address, passphrase)
}

// Update mocks base method
func (m *MockAccountManagerOperator) Update(address types.Address, passphrase, newPassphrase string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", address, passphrase, newPassphrase)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update
func (mr *MockAccountManagerOperatorMockRecorder) Update(address, passphrase, newPassphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockAccountManagerOperator)(nil).Update), address, passphrase, newPassphrase)
}

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

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

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

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

// Unlock mocks base method
func (m *MockAccountManagerOperator) Unlock(address types.Address, passphrase string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unlock", address, passphrase)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unlock indicates an expected call of Unlock
func (mr *MockAccountManagerOperatorMockRecorder) Unlock(address, passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockAccountManagerOperator)(nil).Unlock), address, passphrase)
}

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

// UnlockDefault indicates an expected call of UnlockDefault
func (mr *MockAccountManagerOperatorMockRecorder) UnlockDefault(passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockDefault", reflect.TypeOf((*MockAccountManagerOperator)(nil).UnlockDefault), passphrase)
}

// TimedUnlock mocks base method
func (m *MockAccountManagerOperator) TimedUnlock(address types.Address, passphrase string, timeout time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimedUnlock", address, passphrase, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// TimedUnlock indicates an expected call of TimedUnlock
func (mr *MockAccountManagerOperatorMockRecorder) TimedUnlock(address, passphrase, timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimedUnlock", reflect.TypeOf((*MockAccountManagerOperator)(nil).TimedUnlock), address, passphrase, timeout)
}

// TimedUnlockDefault mocks base method
func (m *MockAccountManagerOperator) TimedUnlockDefault(passphrase string, timeout time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TimedUnlockDefault", passphrase, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// TimedUnlockDefault indicates an expected call of TimedUnlockDefault
func (mr *MockAccountManagerOperatorMockRecorder) TimedUnlockDefault(passphrase, timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimedUnlockDefault", reflect.TypeOf((*MockAccountManagerOperator)(nil).TimedUnlockDefault), passphrase, timeout)
}

// Lock mocks base method
func (m *MockAccountManagerOperator) Lock(address types.Address) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Lock", address)
	ret0, _ := ret[0].(error)
	return ret0
}

// Lock indicates an expected call of Lock
func (mr *MockAccountManagerOperatorMockRecorder) Lock(address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockAccountManagerOperator)(nil).Lock), address)
}

// SignTransaction mocks base method
func (m *MockAccountManagerOperator) SignTransaction(tx types.UnsignedTransaction) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignTransaction", tx)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignTransaction indicates an expected call of SignTransaction
func (mr *MockAccountManagerOperatorMockRecorder) SignTransaction(tx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignTransaction", reflect.TypeOf((*MockAccountManagerOperator)(nil).SignTransaction), tx)
}

// SignAndEcodeTransactionWithPassphrase mocks base method
func (m *MockAccountManagerOperator) SignAndEcodeTransactionWithPassphrase(tx types.UnsignedTransaction, passphrase string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignAndEcodeTransactionWithPassphrase", tx, passphrase)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignAndEcodeTransactionWithPassphrase indicates an expected call of SignAndEcodeTransactionWithPassphrase
func (mr *MockAccountManagerOperatorMockRecorder) SignAndEcodeTransactionWithPassphrase(tx, passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignAndEcodeTransactionWithPassphrase", reflect.TypeOf((*MockAccountManagerOperator)(nil).SignAndEcodeTransactionWithPassphrase), tx, passphrase)
}

// SignTransactionWithPassphrase mocks base method
func (m *MockAccountManagerOperator) SignTransactionWithPassphrase(tx types.UnsignedTransaction, passphrase string) (*types.SignedTransaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignTransactionWithPassphrase", tx, passphrase)
	ret0, _ := ret[0].(*types.SignedTransaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignTransactionWithPassphrase indicates an expected call of SignTransactionWithPassphrase
func (mr *MockAccountManagerOperatorMockRecorder) SignTransactionWithPassphrase(tx, passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignTransactionWithPassphrase", reflect.TypeOf((*MockAccountManagerOperator)(nil).SignTransactionWithPassphrase), tx, passphrase)
}

// Sign mocks base method
func (m *MockAccountManagerOperator) Sign(tx types.UnsignedTransaction, passphrase string) (byte, []byte, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sign", tx, passphrase)
	ret0, _ := ret[0].(byte)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].([]byte)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// Sign indicates an expected call of Sign
func (mr *MockAccountManagerOperatorMockRecorder) Sign(tx, passphrase interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*MockAccountManagerOperator)(nil).Sign), tx, passphrase)
}

// MockrpcRequester is a mock of rpcRequester interface
type MockrpcRequester struct {
	ctrl     *gomock.Controller
	recorder *MockrpcRequesterMockRecorder
}

// MockrpcRequesterMockRecorder is the mock recorder for MockrpcRequester
type MockrpcRequesterMockRecorder struct {
	mock *MockrpcRequester
}

// NewMockrpcRequester creates a new mock instance
func NewMockrpcRequester(ctrl *gomock.Controller) *MockrpcRequester {
	mock := &MockrpcRequester{ctrl: ctrl}
	mock.recorder = &MockrpcRequesterMockRecorder{mock}
	return mock
}

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

// Call mocks base method
func (m *MockrpcRequester) Call(resultPtr interface{}, method string, args ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{resultPtr, method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Call", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Call indicates an expected call of Call
func (mr *MockrpcRequesterMockRecorder) Call(resultPtr, method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{resultPtr, method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockrpcRequester)(nil).Call), varargs...)
}

// BatchCall mocks base method
func (m *MockrpcRequester) BatchCall(b []rpc.BatchElem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCall", b)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCall indicates an expected call of BatchCall
func (mr *MockrpcRequesterMockRecorder) BatchCall(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCall", reflect.TypeOf((*MockrpcRequester)(nil).BatchCall), b)
}

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

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