SmartContract_mock.go

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

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

import (
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockISmartContract is a mock of ISmartContract interface
type MockISmartContract struct {
	ctrl     *gomock.Controller
	recorder *MockISmartContractMockRecorder
}

// MockISmartContractMockRecorder is the mock recorder for MockISmartContract
type MockISmartContractMockRecorder struct {
	mock *MockISmartContract
}

// NewMockISmartContract creates a new mock instance
func NewMockISmartContract(ctrl *gomock.Controller) *MockISmartContract {
	mock := &MockISmartContract{ctrl: ctrl}
	mock.recorder = &MockISmartContractMockRecorder{mock}
	return mock
}

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

// NewPrivateKey mocks base method
func (m *MockISmartContract) NewPrivateKey(input *NewPrivateKeyInput) (*NewPrivateKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewPrivateKey", input)
	ret0, _ := ret[0].(*NewPrivateKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewPrivateKey indicates an expected call of NewPrivateKey
func (mr *MockISmartContractMockRecorder) NewPrivateKey(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPrivateKey", reflect.TypeOf((*MockISmartContract)(nil).NewPrivateKey), input)
}

// GetPublicKey mocks base method
func (m *MockISmartContract) GetPublicKey(input *GetPublicKeyInput) (*GetPublicKeyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPublicKey", input)
	ret0, _ := ret[0].(*GetPublicKeyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPublicKey indicates an expected call of GetPublicKey
func (mr *MockISmartContractMockRecorder) GetPublicKey(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicKey", reflect.TypeOf((*MockISmartContract)(nil).GetPublicKey), input)
}

// GetAddress mocks base method
func (m *MockISmartContract) GetAddress(key *GetAddressInput) (*GetAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress", key)
	ret0, _ := ret[0].(*GetAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAddress indicates an expected call of GetAddress
func (mr *MockISmartContractMockRecorder) GetAddress(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockISmartContract)(nil).GetAddress), key)
}

// GetPalletOneMappingAddress mocks base method
func (m *MockISmartContract) GetPalletOneMappingAddress(addr *GetPalletOneMappingAddressInput) (*GetPalletOneMappingAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPalletOneMappingAddress", addr)
	ret0, _ := ret[0].(*GetPalletOneMappingAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPalletOneMappingAddress indicates an expected call of GetPalletOneMappingAddress
func (mr *MockISmartContractMockRecorder) GetPalletOneMappingAddress(addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPalletOneMappingAddress", reflect.TypeOf((*MockISmartContract)(nil).GetPalletOneMappingAddress), addr)
}

// SignMessage mocks base method
func (m *MockISmartContract) SignMessage(input *SignMessageInput) (*SignMessageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignMessage", input)
	ret0, _ := ret[0].(*SignMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignMessage indicates an expected call of SignMessage
func (mr *MockISmartContractMockRecorder) SignMessage(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMessage", reflect.TypeOf((*MockISmartContract)(nil).SignMessage), input)
}

// VerifySignature mocks base method
func (m *MockISmartContract) VerifySignature(input *VerifySignatureInput) (*VerifySignatureOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifySignature", input)
	ret0, _ := ret[0].(*VerifySignatureOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifySignature indicates an expected call of VerifySignature
func (mr *MockISmartContractMockRecorder) VerifySignature(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifySignature", reflect.TypeOf((*MockISmartContract)(nil).VerifySignature), input)
}

// SignTransaction mocks base method
func (m *MockISmartContract) SignTransaction(input *SignTransactionInput) (*SignTransactionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignTransaction", input)
	ret0, _ := ret[0].(*SignTransactionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BindTxAndSignature mocks base method
func (m *MockISmartContract) BindTxAndSignature(input *BindTxAndSignatureInput) (*BindTxAndSignatureOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BindTxAndSignature", input)
	ret0, _ := ret[0].(*BindTxAndSignatureOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BindTxAndSignature indicates an expected call of BindTxAndSignature
func (mr *MockISmartContractMockRecorder) BindTxAndSignature(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindTxAndSignature", reflect.TypeOf((*MockISmartContract)(nil).BindTxAndSignature), input)
}

// CalcTxHash mocks base method
func (m *MockISmartContract) CalcTxHash(input *CalcTxHashInput) (*CalcTxHashOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcTxHash", input)
	ret0, _ := ret[0].(*CalcTxHashOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcTxHash indicates an expected call of CalcTxHash
func (mr *MockISmartContractMockRecorder) CalcTxHash(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcTxHash", reflect.TypeOf((*MockISmartContract)(nil).CalcTxHash), input)
}

// SendTransaction mocks base method
func (m *MockISmartContract) SendTransaction(input *SendTransactionInput) (*SendTransactionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendTransaction", input)
	ret0, _ := ret[0].(*SendTransactionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTxBasicInfo mocks base method
func (m *MockISmartContract) GetTxBasicInfo(input *GetTxBasicInfoInput) (*GetTxBasicInfoOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTxBasicInfo", input)
	ret0, _ := ret[0].(*GetTxBasicInfoOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTxBasicInfo indicates an expected call of GetTxBasicInfo
func (mr *MockISmartContractMockRecorder) GetTxBasicInfo(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxBasicInfo", reflect.TypeOf((*MockISmartContract)(nil).GetTxBasicInfo), input)
}

// GetBlockInfo mocks base method
func (m *MockISmartContract) GetBlockInfo(input *GetBlockInfoInput) (*GetBlockInfoOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockInfo", input)
	ret0, _ := ret[0].(*GetBlockInfoOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockInfo indicates an expected call of GetBlockInfo
func (mr *MockISmartContractMockRecorder) GetBlockInfo(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockInfo", reflect.TypeOf((*MockISmartContract)(nil).GetBlockInfo), input)
}

// CreateContractInstallTx mocks base method
func (m *MockISmartContract) CreateContractInstallTx(input *CreateContractInstallTxInput) (*CreateContractInstallTxOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContractInstallTx", input)
	ret0, _ := ret[0].(*CreateContractInstallTxOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContractInstallTx indicates an expected call of CreateContractInstallTx
func (mr *MockISmartContractMockRecorder) CreateContractInstallTx(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContractInstallTx", reflect.TypeOf((*MockISmartContract)(nil).CreateContractInstallTx), input)
}

// GetContractInstallTx mocks base method
func (m *MockISmartContract) GetContractInstallTx(input *GetContractInstallTxInput) (*GetContractInstallTxOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContractInstallTx", input)
	ret0, _ := ret[0].(*GetContractInstallTxOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContractInstallTx indicates an expected call of GetContractInstallTx
func (mr *MockISmartContractMockRecorder) GetContractInstallTx(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractInstallTx", reflect.TypeOf((*MockISmartContract)(nil).GetContractInstallTx), input)
}

// CreateContractInitialTx mocks base method
func (m *MockISmartContract) CreateContractInitialTx(input *CreateContractInitialTxInput) (*CreateContractInitialTxOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContractInitialTx", input)
	ret0, _ := ret[0].(*CreateContractInitialTxOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContractInitialTx indicates an expected call of CreateContractInitialTx
func (mr *MockISmartContractMockRecorder) CreateContractInitialTx(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContractInitialTx", reflect.TypeOf((*MockISmartContract)(nil).CreateContractInitialTx), input)
}

// GetContractInitialTx mocks base method
func (m *MockISmartContract) GetContractInitialTx(input *GetContractInitialTxInput) (*GetContractInitialTxOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContractInitialTx", input)
	ret0, _ := ret[0].(*GetContractInitialTxOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContractInitialTx indicates an expected call of GetContractInitialTx
func (mr *MockISmartContractMockRecorder) GetContractInitialTx(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractInitialTx", reflect.TypeOf((*MockISmartContract)(nil).GetContractInitialTx), input)
}

// CreateContractInvokeTx mocks base method
func (m *MockISmartContract) CreateContractInvokeTx(input *CreateContractInvokeTxInput) (*CreateContractInvokeTxOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContractInvokeTx", input)
	ret0, _ := ret[0].(*CreateContractInvokeTxOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContractInvokeTx indicates an expected call of CreateContractInvokeTx
func (mr *MockISmartContractMockRecorder) CreateContractInvokeTx(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContractInvokeTx", reflect.TypeOf((*MockISmartContract)(nil).CreateContractInvokeTx), input)
}

// GetContractInvokeTx mocks base method
func (m *MockISmartContract) GetContractInvokeTx(input *GetContractInvokeTxInput) (*GetContractInvokeTxOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContractInvokeTx", input)
	ret0, _ := ret[0].(*GetContractInvokeTxOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContractInvokeTx indicates an expected call of GetContractInvokeTx
func (mr *MockISmartContractMockRecorder) GetContractInvokeTx(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractInvokeTx", reflect.TypeOf((*MockISmartContract)(nil).GetContractInvokeTx), input)
}

// QueryContract mocks base method
func (m *MockISmartContract) QueryContract(input *QueryContractInput) (*QueryContractOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryContract", input)
	ret0, _ := ret[0].(*QueryContractOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryContract indicates an expected call of QueryContract
func (mr *MockISmartContractMockRecorder) QueryContract(input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryContract", reflect.TypeOf((*MockISmartContract)(nil).QueryContract), input)
}