From 8e60111ee106727efeff2e39a43555d1749c667f Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 10 Mar 2025 03:15:27 +0000 Subject: [PATCH 01/14] add service test mock Signed-off-by: Daisuke Kanda --- Makefile | 7 +- core/chain_testmock.go | 1346 +++++++++++++++++++++++++++++++++++ core/headers_testmock.go | 849 ++++++++++++++++++++++ core/provers_testmock.go | 908 +++++++++++++++++++++++ core/service_test.go | 86 +++ core/strategies_testmock.go | 156 ++++ go.mod | 1 + go.sum | 2 + 8 files changed, 3353 insertions(+), 2 deletions(-) create mode 100644 core/chain_testmock.go create mode 100644 core/headers_testmock.go create mode 100644 core/provers_testmock.go create mode 100644 core/service_test.go create mode 100644 core/strategies_testmock.go diff --git a/Makefile b/Makefile index 0df09b96..7cc724f8 100644 --- a/Makefile +++ b/Makefile @@ -8,8 +8,9 @@ protoImage=$(DOCKER) run --user 0 --rm -v $(CURDIR):/workspace --workdir /worksp build: go build -o ./build/yrly . +TESTMOCKS = core/strategies_testmock.go core/provers_testmock.go core/chain_testmock.go core/headers_testmock.go .PHONY: test -test: +test: $(TESTMOCKS) go test -v ./... proto-gen: @@ -18,6 +19,8 @@ proto-gen: proto-update-deps: @echo "Updating Protobuf dependencies" - $(DOCKER) run --user 0 --rm -v $(CURDIR)/proto:/workspace --workdir /workspace $(protoImageName) buf mod update + +$(TESTMOCKS): + for f in $@; do mockgen -source `echo $$f | sed -e s/_testmock//g` -destination $$f -package core; done .PHONY: proto-gen proto-update-deps diff --git a/core/chain_testmock.go b/core/chain_testmock.go new file mode 100644 index 00000000..50cff53f --- /dev/null +++ b/core/chain_testmock.go @@ -0,0 +1,1346 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: core/chain.go +// +// Generated by this command: +// +// mockgen -source core/chain.go -destination core/chain_testmock.go -package core +// + +// Package core is a generated GoMock package. +package core + +import ( + context "context" + reflect "reflect" + time "time" + + codec "github.com/cosmos/cosmos-sdk/codec" + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + types2 "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + types3 "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + exported "github.com/cosmos/ibc-go/v8/modules/core/exported" + gomock "go.uber.org/mock/gomock" +) + +// MockChain is a mock of Chain interface. +type MockChain struct { + ctrl *gomock.Controller + recorder *MockChainMockRecorder + isgomock struct{} +} + +// MockChainMockRecorder is the mock recorder for MockChain. +type MockChainMockRecorder struct { + mock *MockChain +} + +// NewMockChain creates a new mock instance. +func NewMockChain(ctrl *gomock.Controller) *MockChain { + mock := &MockChain{ctrl: ctrl} + mock.recorder = &MockChainMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChain) EXPECT() *MockChainMockRecorder { + return m.recorder +} + +// AverageBlockTime mocks base method. +func (m *MockChain) AverageBlockTime() time.Duration { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AverageBlockTime") + ret0, _ := ret[0].(time.Duration) + return ret0 +} + +// AverageBlockTime indicates an expected call of AverageBlockTime. +func (mr *MockChainMockRecorder) AverageBlockTime() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChain)(nil).AverageBlockTime)) +} + +// ChainID mocks base method. +func (m *MockChain) ChainID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChainID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ChainID indicates an expected call of ChainID. +func (mr *MockChainMockRecorder) ChainID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChain)(nil).ChainID)) +} + +// Codec mocks base method. +func (m *MockChain) Codec() codec.ProtoCodecMarshaler { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Codec") + ret0, _ := ret[0].(codec.ProtoCodecMarshaler) + return ret0 +} + +// Codec indicates an expected call of Codec. +func (mr *MockChainMockRecorder) Codec() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Codec", reflect.TypeOf((*MockChain)(nil).Codec)) +} + +// GetAddress mocks base method. +func (m *MockChain) GetAddress() (types.AccAddress, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAddress") + ret0, _ := ret[0].(types.AccAddress) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAddress indicates an expected call of GetAddress. +func (mr *MockChainMockRecorder) GetAddress() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockChain)(nil).GetAddress)) +} + +// GetMsgResult mocks base method. +func (m *MockChain) GetMsgResult(ctx context.Context, id MsgID) (MsgResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMsgResult", ctx, id) + ret0, _ := ret[0].(MsgResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMsgResult indicates an expected call of GetMsgResult. +func (mr *MockChainMockRecorder) GetMsgResult(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMsgResult", reflect.TypeOf((*MockChain)(nil).GetMsgResult), ctx, id) +} + +// Init mocks base method. +func (m *MockChain) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) + ret0, _ := ret[0].(error) + return ret0 +} + +// Init indicates an expected call of Init. +func (mr *MockChainMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockChain)(nil).Init), homePath, timeout, codec, debug) +} + +// LatestHeight mocks base method. +func (m *MockChain) LatestHeight(ctx context.Context) (exported.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LatestHeight", ctx) + ret0, _ := ret[0].(exported.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LatestHeight indicates an expected call of LatestHeight. +func (mr *MockChainMockRecorder) LatestHeight(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChain)(nil).LatestHeight), ctx) +} + +// Path mocks base method. +func (m *MockChain) Path() *PathEnd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Path") + ret0, _ := ret[0].(*PathEnd) + return ret0 +} + +// Path indicates an expected call of Path. +func (mr *MockChainMockRecorder) Path() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockChain)(nil).Path)) +} + +// QueryBalance mocks base method. +func (m *MockChain) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryBalance", ctx, address) + ret0, _ := ret[0].(types.Coins) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryBalance indicates an expected call of QueryBalance. +func (mr *MockChainMockRecorder) QueryBalance(ctx, address any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockChain)(nil).QueryBalance), ctx, address) +} + +// QueryCanTransitionToFlushComplete mocks base method. +func (m *MockChain) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. +func (mr *MockChainMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockChain)(nil).QueryCanTransitionToFlushComplete), ctx) +} + +// QueryChannel mocks base method. +func (m *MockChain) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannel", ctx) + ret0, _ := ret[0].(*types3.QueryChannelResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannel indicates an expected call of QueryChannel. +func (mr *MockChainMockRecorder) QueryChannel(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockChain)(nil).QueryChannel), ctx) +} + +// QueryChannelUpgrade mocks base method. +func (m *MockChain) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. +func (mr *MockChainMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockChain)(nil).QueryChannelUpgrade), ctx) +} + +// QueryChannelUpgradeError mocks base method. +func (m *MockChain) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. +func (mr *MockChainMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockChain)(nil).QueryChannelUpgradeError), ctx) +} + +// QueryClientConsensusState mocks base method. +func (m *MockChain) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) + ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. +func (mr *MockChainMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockChain)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) +} + +// QueryClientState mocks base method. +func (m *MockChain) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientState", ctx) + ret0, _ := ret[0].(*types1.QueryClientStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientState indicates an expected call of QueryClientState. +func (mr *MockChainMockRecorder) QueryClientState(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockChain)(nil).QueryClientState), ctx) +} + +// QueryConnection mocks base method. +func (m *MockChain) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) + ret0, _ := ret[0].(*types2.QueryConnectionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryConnection indicates an expected call of QueryConnection. +func (mr *MockChainMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockChain)(nil).QueryConnection), ctx, connectionID) +} + +// QueryDenomTraces mocks base method. +func (m *MockChain) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) + ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryDenomTraces indicates an expected call of QueryDenomTraces. +func (mr *MockChainMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockChain)(nil).QueryDenomTraces), ctx, offset, limit) +} + +// QueryNextSequenceReceive mocks base method. +func (m *MockChain) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockChainMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockChain)(nil).QueryNextSequenceReceive), ctx) +} + +// QueryUnfinalizedRelayAcknowledgements mocks base method. +func (m *MockChain) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. +func (mr *MockChainMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockChain)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) +} + +// QueryUnfinalizedRelayPackets mocks base method. +func (m *MockChain) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. +func (mr *MockChainMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockChain)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) +} + +// QueryUnreceivedAcknowledgements mocks base method. +func (m *MockChain) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. +func (mr *MockChainMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockChain)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) +} + +// QueryUnreceivedPackets mocks base method. +func (m *MockChain) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. +func (mr *MockChainMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockChain)(nil).QueryUnreceivedPackets), ctx, seqs) +} + +// RegisterMsgEventListener mocks base method. +func (m *MockChain) RegisterMsgEventListener(arg0 MsgEventListener) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterMsgEventListener", arg0) +} + +// RegisterMsgEventListener indicates an expected call of RegisterMsgEventListener. +func (mr *MockChainMockRecorder) RegisterMsgEventListener(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMsgEventListener", reflect.TypeOf((*MockChain)(nil).RegisterMsgEventListener), arg0) +} + +// SendMsgs mocks base method. +func (m *MockChain) SendMsgs(ctx context.Context, msgs []types.Msg) ([]MsgID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendMsgs", ctx, msgs) + ret0, _ := ret[0].([]MsgID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMsgs indicates an expected call of SendMsgs. +func (mr *MockChainMockRecorder) SendMsgs(ctx, msgs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsgs", reflect.TypeOf((*MockChain)(nil).SendMsgs), ctx, msgs) +} + +// SetRelayInfo mocks base method. +func (m *MockChain) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRelayInfo indicates an expected call of SetRelayInfo. +func (mr *MockChainMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockChain)(nil).SetRelayInfo), path, counterparty, counterpartyPath) +} + +// SetupForRelay mocks base method. +func (m *MockChain) SetupForRelay(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupForRelay", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetupForRelay indicates an expected call of SetupForRelay. +func (mr *MockChainMockRecorder) SetupForRelay(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockChain)(nil).SetupForRelay), ctx) +} + +// Timestamp mocks base method. +func (m *MockChain) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Timestamp", ctx, height) + ret0, _ := ret[0].(time.Time) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Timestamp indicates an expected call of Timestamp. +func (mr *MockChainMockRecorder) Timestamp(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChain)(nil).Timestamp), ctx, height) +} + +// MockChainInfo is a mock of ChainInfo interface. +type MockChainInfo struct { + ctrl *gomock.Controller + recorder *MockChainInfoMockRecorder + isgomock struct{} +} + +// MockChainInfoMockRecorder is the mock recorder for MockChainInfo. +type MockChainInfoMockRecorder struct { + mock *MockChainInfo +} + +// NewMockChainInfo creates a new mock instance. +func NewMockChainInfo(ctrl *gomock.Controller) *MockChainInfo { + mock := &MockChainInfo{ctrl: ctrl} + mock.recorder = &MockChainInfoMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChainInfo) EXPECT() *MockChainInfoMockRecorder { + return m.recorder +} + +// AverageBlockTime mocks base method. +func (m *MockChainInfo) AverageBlockTime() time.Duration { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AverageBlockTime") + ret0, _ := ret[0].(time.Duration) + return ret0 +} + +// AverageBlockTime indicates an expected call of AverageBlockTime. +func (mr *MockChainInfoMockRecorder) AverageBlockTime() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainInfo)(nil).AverageBlockTime)) +} + +// ChainID mocks base method. +func (m *MockChainInfo) ChainID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChainID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ChainID indicates an expected call of ChainID. +func (mr *MockChainInfoMockRecorder) ChainID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainInfo)(nil).ChainID)) +} + +// LatestHeight mocks base method. +func (m *MockChainInfo) LatestHeight(ctx context.Context) (exported.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LatestHeight", ctx) + ret0, _ := ret[0].(exported.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LatestHeight indicates an expected call of LatestHeight. +func (mr *MockChainInfoMockRecorder) LatestHeight(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainInfo)(nil).LatestHeight), ctx) +} + +// Timestamp mocks base method. +func (m *MockChainInfo) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Timestamp", ctx, height) + ret0, _ := ret[0].(time.Time) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Timestamp indicates an expected call of Timestamp. +func (mr *MockChainInfoMockRecorder) Timestamp(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainInfo)(nil).Timestamp), ctx, height) +} + +// MockMsgEventListener is a mock of MsgEventListener interface. +type MockMsgEventListener struct { + ctrl *gomock.Controller + recorder *MockMsgEventListenerMockRecorder + isgomock struct{} +} + +// MockMsgEventListenerMockRecorder is the mock recorder for MockMsgEventListener. +type MockMsgEventListenerMockRecorder struct { + mock *MockMsgEventListener +} + +// NewMockMsgEventListener creates a new mock instance. +func NewMockMsgEventListener(ctrl *gomock.Controller) *MockMsgEventListener { + mock := &MockMsgEventListener{ctrl: ctrl} + mock.recorder = &MockMsgEventListenerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMsgEventListener) EXPECT() *MockMsgEventListenerMockRecorder { + return m.recorder +} + +// OnSentMsg mocks base method. +func (m *MockMsgEventListener) OnSentMsg(ctx context.Context, msgs []types.Msg) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OnSentMsg", ctx, msgs) + ret0, _ := ret[0].(error) + return ret0 +} + +// OnSentMsg indicates an expected call of OnSentMsg. +func (mr *MockMsgEventListenerMockRecorder) OnSentMsg(ctx, msgs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnSentMsg", reflect.TypeOf((*MockMsgEventListener)(nil).OnSentMsg), ctx, msgs) +} + +// MockIBCQuerier is a mock of IBCQuerier interface. +type MockIBCQuerier struct { + ctrl *gomock.Controller + recorder *MockIBCQuerierMockRecorder + isgomock struct{} +} + +// MockIBCQuerierMockRecorder is the mock recorder for MockIBCQuerier. +type MockIBCQuerierMockRecorder struct { + mock *MockIBCQuerier +} + +// NewMockIBCQuerier creates a new mock instance. +func NewMockIBCQuerier(ctrl *gomock.Controller) *MockIBCQuerier { + mock := &MockIBCQuerier{ctrl: ctrl} + mock.recorder = &MockIBCQuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIBCQuerier) EXPECT() *MockIBCQuerierMockRecorder { + return m.recorder +} + +// QueryCanTransitionToFlushComplete mocks base method. +func (m *MockIBCQuerier) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. +func (mr *MockIBCQuerierMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockIBCQuerier)(nil).QueryCanTransitionToFlushComplete), ctx) +} + +// QueryChannel mocks base method. +func (m *MockIBCQuerier) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannel", ctx) + ret0, _ := ret[0].(*types3.QueryChannelResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannel indicates an expected call of QueryChannel. +func (mr *MockIBCQuerierMockRecorder) QueryChannel(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockIBCQuerier)(nil).QueryChannel), ctx) +} + +// QueryChannelUpgrade mocks base method. +func (m *MockIBCQuerier) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. +func (mr *MockIBCQuerierMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockIBCQuerier)(nil).QueryChannelUpgrade), ctx) +} + +// QueryChannelUpgradeError mocks base method. +func (m *MockIBCQuerier) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. +func (mr *MockIBCQuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockIBCQuerier)(nil).QueryChannelUpgradeError), ctx) +} + +// QueryClientConsensusState mocks base method. +func (m *MockIBCQuerier) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) + ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. +func (mr *MockIBCQuerierMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockIBCQuerier)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) +} + +// QueryClientState mocks base method. +func (m *MockIBCQuerier) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientState", ctx) + ret0, _ := ret[0].(*types1.QueryClientStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientState indicates an expected call of QueryClientState. +func (mr *MockIBCQuerierMockRecorder) QueryClientState(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockIBCQuerier)(nil).QueryClientState), ctx) +} + +// QueryConnection mocks base method. +func (m *MockIBCQuerier) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) + ret0, _ := ret[0].(*types2.QueryConnectionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryConnection indicates an expected call of QueryConnection. +func (mr *MockIBCQuerierMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockIBCQuerier)(nil).QueryConnection), ctx, connectionID) +} + +// QueryNextSequenceReceive mocks base method. +func (m *MockIBCQuerier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockIBCQuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockIBCQuerier)(nil).QueryNextSequenceReceive), ctx) +} + +// QueryUnfinalizedRelayAcknowledgements mocks base method. +func (m *MockIBCQuerier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. +func (mr *MockIBCQuerierMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) +} + +// QueryUnfinalizedRelayPackets mocks base method. +func (m *MockIBCQuerier) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. +func (mr *MockIBCQuerierMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) +} + +// QueryUnreceivedAcknowledgements mocks base method. +func (m *MockIBCQuerier) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. +func (mr *MockIBCQuerierMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) +} + +// QueryUnreceivedPackets mocks base method. +func (m *MockIBCQuerier) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. +func (mr *MockIBCQuerierMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnreceivedPackets), ctx, seqs) +} + +// MockICS02Querier is a mock of ICS02Querier interface. +type MockICS02Querier struct { + ctrl *gomock.Controller + recorder *MockICS02QuerierMockRecorder + isgomock struct{} +} + +// MockICS02QuerierMockRecorder is the mock recorder for MockICS02Querier. +type MockICS02QuerierMockRecorder struct { + mock *MockICS02Querier +} + +// NewMockICS02Querier creates a new mock instance. +func NewMockICS02Querier(ctrl *gomock.Controller) *MockICS02Querier { + mock := &MockICS02Querier{ctrl: ctrl} + mock.recorder = &MockICS02QuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockICS02Querier) EXPECT() *MockICS02QuerierMockRecorder { + return m.recorder +} + +// QueryClientConsensusState mocks base method. +func (m *MockICS02Querier) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) + ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. +func (mr *MockICS02QuerierMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockICS02Querier)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) +} + +// QueryClientState mocks base method. +func (m *MockICS02Querier) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientState", ctx) + ret0, _ := ret[0].(*types1.QueryClientStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientState indicates an expected call of QueryClientState. +func (mr *MockICS02QuerierMockRecorder) QueryClientState(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockICS02Querier)(nil).QueryClientState), ctx) +} + +// MockICS03Querier is a mock of ICS03Querier interface. +type MockICS03Querier struct { + ctrl *gomock.Controller + recorder *MockICS03QuerierMockRecorder + isgomock struct{} +} + +// MockICS03QuerierMockRecorder is the mock recorder for MockICS03Querier. +type MockICS03QuerierMockRecorder struct { + mock *MockICS03Querier +} + +// NewMockICS03Querier creates a new mock instance. +func NewMockICS03Querier(ctrl *gomock.Controller) *MockICS03Querier { + mock := &MockICS03Querier{ctrl: ctrl} + mock.recorder = &MockICS03QuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockICS03Querier) EXPECT() *MockICS03QuerierMockRecorder { + return m.recorder +} + +// QueryConnection mocks base method. +func (m *MockICS03Querier) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) + ret0, _ := ret[0].(*types2.QueryConnectionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryConnection indicates an expected call of QueryConnection. +func (mr *MockICS03QuerierMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockICS03Querier)(nil).QueryConnection), ctx, connectionID) +} + +// MockICS04Querier is a mock of ICS04Querier interface. +type MockICS04Querier struct { + ctrl *gomock.Controller + recorder *MockICS04QuerierMockRecorder + isgomock struct{} +} + +// MockICS04QuerierMockRecorder is the mock recorder for MockICS04Querier. +type MockICS04QuerierMockRecorder struct { + mock *MockICS04Querier +} + +// NewMockICS04Querier creates a new mock instance. +func NewMockICS04Querier(ctrl *gomock.Controller) *MockICS04Querier { + mock := &MockICS04Querier{ctrl: ctrl} + mock.recorder = &MockICS04QuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockICS04Querier) EXPECT() *MockICS04QuerierMockRecorder { + return m.recorder +} + +// QueryCanTransitionToFlushComplete mocks base method. +func (m *MockICS04Querier) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. +func (mr *MockICS04QuerierMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockICS04Querier)(nil).QueryCanTransitionToFlushComplete), ctx) +} + +// QueryChannel mocks base method. +func (m *MockICS04Querier) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannel", ctx) + ret0, _ := ret[0].(*types3.QueryChannelResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannel indicates an expected call of QueryChannel. +func (mr *MockICS04QuerierMockRecorder) QueryChannel(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannel), ctx) +} + +// QueryChannelUpgrade mocks base method. +func (m *MockICS04Querier) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. +func (mr *MockICS04QuerierMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannelUpgrade), ctx) +} + +// QueryChannelUpgradeError mocks base method. +func (m *MockICS04Querier) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. +func (mr *MockICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannelUpgradeError), ctx) +} + +// QueryNextSequenceReceive mocks base method. +func (m *MockICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockICS04Querier)(nil).QueryNextSequenceReceive), ctx) +} + +// QueryUnfinalizedRelayAcknowledgements mocks base method. +func (m *MockICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. +func (mr *MockICS04QuerierMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) +} + +// QueryUnfinalizedRelayPackets mocks base method. +func (m *MockICS04Querier) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. +func (mr *MockICS04QuerierMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) +} + +// QueryUnreceivedAcknowledgements mocks base method. +func (m *MockICS04Querier) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. +func (mr *MockICS04QuerierMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) +} + +// QueryUnreceivedPackets mocks base method. +func (m *MockICS04Querier) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. +func (mr *MockICS04QuerierMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnreceivedPackets), ctx, seqs) +} + +// MockICS20Querier is a mock of ICS20Querier interface. +type MockICS20Querier struct { + ctrl *gomock.Controller + recorder *MockICS20QuerierMockRecorder + isgomock struct{} +} + +// MockICS20QuerierMockRecorder is the mock recorder for MockICS20Querier. +type MockICS20QuerierMockRecorder struct { + mock *MockICS20Querier +} + +// NewMockICS20Querier creates a new mock instance. +func NewMockICS20Querier(ctrl *gomock.Controller) *MockICS20Querier { + mock := &MockICS20Querier{ctrl: ctrl} + mock.recorder = &MockICS20QuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockICS20Querier) EXPECT() *MockICS20QuerierMockRecorder { + return m.recorder +} + +// QueryBalance mocks base method. +func (m *MockICS20Querier) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryBalance", ctx, address) + ret0, _ := ret[0].(types.Coins) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryBalance indicates an expected call of QueryBalance. +func (mr *MockICS20QuerierMockRecorder) QueryBalance(ctx, address any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockICS20Querier)(nil).QueryBalance), ctx, address) +} + +// QueryDenomTraces mocks base method. +func (m *MockICS20Querier) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) + ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryDenomTraces indicates an expected call of QueryDenomTraces. +func (mr *MockICS20QuerierMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockICS20Querier)(nil).QueryDenomTraces), ctx, offset, limit) +} + +// MockLightClientICS04Querier is a mock of LightClientICS04Querier interface. +type MockLightClientICS04Querier struct { + ctrl *gomock.Controller + recorder *MockLightClientICS04QuerierMockRecorder + isgomock struct{} +} + +// MockLightClientICS04QuerierMockRecorder is the mock recorder for MockLightClientICS04Querier. +type MockLightClientICS04QuerierMockRecorder struct { + mock *MockLightClientICS04Querier +} + +// NewMockLightClientICS04Querier creates a new mock instance. +func NewMockLightClientICS04Querier(ctrl *gomock.Controller) *MockLightClientICS04Querier { + mock := &MockLightClientICS04Querier{ctrl: ctrl} + mock.recorder = &MockLightClientICS04QuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLightClientICS04Querier) EXPECT() *MockLightClientICS04QuerierMockRecorder { + return m.recorder +} + +// CheckRefreshRequired mocks base method. +func (m *MockLightClientICS04Querier) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. +func (mr *MockLightClientICS04QuerierMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockLightClientICS04Querier)(nil).CheckRefreshRequired), ctx, counterparty) +} + +// CreateInitialLightClientState mocks base method. +func (m *MockLightClientICS04Querier) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) + ret0, _ := ret[0].(exported.ClientState) + ret1, _ := ret[1].(exported.ConsensusState) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. +func (mr *MockLightClientICS04QuerierMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockLightClientICS04Querier)(nil).CreateInitialLightClientState), ctx, height) +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockLightClientICS04Querier) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockLightClientICS04QuerierMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockLightClientICS04Querier)(nil).GetLatestFinalizedHeader), ctx) +} + +// QueryCanTransitionToFlushComplete mocks base method. +func (m *MockLightClientICS04Querier) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryCanTransitionToFlushComplete), ctx) +} + +// QueryChannel mocks base method. +func (m *MockLightClientICS04Querier) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannel", ctx) + ret0, _ := ret[0].(*types3.QueryChannelResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannel indicates an expected call of QueryChannel. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannel(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannel), ctx) +} + +// QueryChannelUpgrade mocks base method. +func (m *MockLightClientICS04Querier) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannelUpgrade), ctx) +} + +// QueryChannelUpgradeError mocks base method. +func (m *MockLightClientICS04Querier) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannelUpgradeError), ctx) +} + +// QueryNextSequenceReceive mocks base method. +func (m *MockLightClientICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryNextSequenceReceive), ctx) +} + +// QueryUnfinalizedRelayAcknowledgements mocks base method. +func (m *MockLightClientICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) +} + +// QueryUnfinalizedRelayPackets mocks base method. +func (m *MockLightClientICS04Querier) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) +} + +// QueryUnreceivedAcknowledgements mocks base method. +func (m *MockLightClientICS04Querier) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) +} + +// QueryUnreceivedPackets mocks base method. +func (m *MockLightClientICS04Querier) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnreceivedPackets), ctx, seqs) +} + +// SetupHeadersForUpdate mocks base method. +func (m *MockLightClientICS04Querier) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. +func (mr *MockLightClientICS04QuerierMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockLightClientICS04Querier)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) +} + +// MockQueryContext is a mock of QueryContext interface. +type MockQueryContext struct { + ctrl *gomock.Controller + recorder *MockQueryContextMockRecorder + isgomock struct{} +} + +// MockQueryContextMockRecorder is the mock recorder for MockQueryContext. +type MockQueryContextMockRecorder struct { + mock *MockQueryContext +} + +// NewMockQueryContext creates a new mock instance. +func NewMockQueryContext(ctrl *gomock.Controller) *MockQueryContext { + mock := &MockQueryContext{ctrl: ctrl} + mock.recorder = &MockQueryContextMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockQueryContext) EXPECT() *MockQueryContextMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockQueryContext) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockQueryContextMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockQueryContext)(nil).Context)) +} + +// Height mocks base method. +func (m *MockQueryContext) Height() exported.Height { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Height") + ret0, _ := ret[0].(exported.Height) + return ret0 +} + +// Height indicates an expected call of Height. +func (mr *MockQueryContextMockRecorder) Height() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockQueryContext)(nil).Height)) +} diff --git a/core/headers_testmock.go b/core/headers_testmock.go new file mode 100644 index 00000000..6c43ba28 --- /dev/null +++ b/core/headers_testmock.go @@ -0,0 +1,849 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: core/headers.go +// +// Generated by this command: +// +// mockgen -source core/headers.go -destination core/headers_testmock.go -package core +// + +// Package core is a generated GoMock package. +package core + +import ( + context "context" + reflect "reflect" + time "time" + + codec "github.com/cosmos/cosmos-sdk/codec" + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + types2 "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + types3 "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + exported "github.com/cosmos/ibc-go/v8/modules/core/exported" + gomock "go.uber.org/mock/gomock" +) + +// MockHeader is a mock of Header interface. +type MockHeader struct { + ctrl *gomock.Controller + recorder *MockHeaderMockRecorder + isgomock struct{} +} + +// MockHeaderMockRecorder is the mock recorder for MockHeader. +type MockHeaderMockRecorder struct { + mock *MockHeader +} + +// NewMockHeader creates a new mock instance. +func NewMockHeader(ctrl *gomock.Controller) *MockHeader { + mock := &MockHeader{ctrl: ctrl} + mock.recorder = &MockHeaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockHeader) EXPECT() *MockHeaderMockRecorder { + return m.recorder +} + +// ClientType mocks base method. +func (m *MockHeader) ClientType() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientType") + ret0, _ := ret[0].(string) + return ret0 +} + +// ClientType indicates an expected call of ClientType. +func (mr *MockHeaderMockRecorder) ClientType() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientType", reflect.TypeOf((*MockHeader)(nil).ClientType)) +} + +// GetHeight mocks base method. +func (m *MockHeader) GetHeight() exported.Height { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHeight") + ret0, _ := ret[0].(exported.Height) + return ret0 +} + +// GetHeight indicates an expected call of GetHeight. +func (mr *MockHeaderMockRecorder) GetHeight() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeight", reflect.TypeOf((*MockHeader)(nil).GetHeight)) +} + +// ProtoMessage mocks base method. +func (m *MockHeader) ProtoMessage() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ProtoMessage") +} + +// ProtoMessage indicates an expected call of ProtoMessage. +func (mr *MockHeaderMockRecorder) ProtoMessage() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProtoMessage", reflect.TypeOf((*MockHeader)(nil).ProtoMessage)) +} + +// Reset mocks base method. +func (m *MockHeader) Reset() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Reset") +} + +// Reset indicates an expected call of Reset. +func (mr *MockHeaderMockRecorder) Reset() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockHeader)(nil).Reset)) +} + +// String mocks base method. +func (m *MockHeader) String() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "String") + ret0, _ := ret[0].(string) + return ret0 +} + +// String indicates an expected call of String. +func (mr *MockHeaderMockRecorder) String() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockHeader)(nil).String)) +} + +// ValidateBasic mocks base method. +func (m *MockHeader) ValidateBasic() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateBasic") + ret0, _ := ret[0].(error) + return ret0 +} + +// ValidateBasic indicates an expected call of ValidateBasic. +func (mr *MockHeaderMockRecorder) ValidateBasic() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateBasic", reflect.TypeOf((*MockHeader)(nil).ValidateBasic)) +} + +// MockSyncHeaders is a mock of SyncHeaders interface. +type MockSyncHeaders struct { + ctrl *gomock.Controller + recorder *MockSyncHeadersMockRecorder + isgomock struct{} +} + +// MockSyncHeadersMockRecorder is the mock recorder for MockSyncHeaders. +type MockSyncHeadersMockRecorder struct { + mock *MockSyncHeaders +} + +// NewMockSyncHeaders creates a new mock instance. +func NewMockSyncHeaders(ctrl *gomock.Controller) *MockSyncHeaders { + mock := &MockSyncHeaders{ctrl: ctrl} + mock.recorder = &MockSyncHeadersMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSyncHeaders) EXPECT() *MockSyncHeadersMockRecorder { + return m.recorder +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockSyncHeaders) GetLatestFinalizedHeader(chainID string) Header { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", chainID) + ret0, _ := ret[0].(Header) + return ret0 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockSyncHeadersMockRecorder) GetLatestFinalizedHeader(chainID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockSyncHeaders)(nil).GetLatestFinalizedHeader), chainID) +} + +// GetQueryContext mocks base method. +func (m *MockSyncHeaders) GetQueryContext(chainID string) QueryContext { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryContext", chainID) + ret0, _ := ret[0].(QueryContext) + return ret0 +} + +// GetQueryContext indicates an expected call of GetQueryContext. +func (mr *MockSyncHeadersMockRecorder) GetQueryContext(chainID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryContext", reflect.TypeOf((*MockSyncHeaders)(nil).GetQueryContext), chainID) +} + +// SetupBothHeadersForUpdate mocks base method. +func (m *MockSyncHeaders) SetupBothHeadersForUpdate(src, dst ChainLightClient) ([]Header, []Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupBothHeadersForUpdate", src, dst) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].([]Header) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// SetupBothHeadersForUpdate indicates an expected call of SetupBothHeadersForUpdate. +func (mr *MockSyncHeadersMockRecorder) SetupBothHeadersForUpdate(src, dst any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupBothHeadersForUpdate", reflect.TypeOf((*MockSyncHeaders)(nil).SetupBothHeadersForUpdate), src, dst) +} + +// SetupHeadersForUpdate mocks base method. +func (m *MockSyncHeaders) SetupHeadersForUpdate(src, dst ChainLightClient) ([]Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupHeadersForUpdate", src, dst) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. +func (mr *MockSyncHeadersMockRecorder) SetupHeadersForUpdate(src, dst any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockSyncHeaders)(nil).SetupHeadersForUpdate), src, dst) +} + +// Updates mocks base method. +func (m *MockSyncHeaders) Updates(src, dst ChainInfoLightClient) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Updates", src, dst) + ret0, _ := ret[0].(error) + return ret0 +} + +// Updates indicates an expected call of Updates. +func (mr *MockSyncHeadersMockRecorder) Updates(src, dst any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Updates", reflect.TypeOf((*MockSyncHeaders)(nil).Updates), src, dst) +} + +// MockChainInfoLightClient is a mock of ChainInfoLightClient interface. +type MockChainInfoLightClient struct { + ctrl *gomock.Controller + recorder *MockChainInfoLightClientMockRecorder + isgomock struct{} +} + +// MockChainInfoLightClientMockRecorder is the mock recorder for MockChainInfoLightClient. +type MockChainInfoLightClientMockRecorder struct { + mock *MockChainInfoLightClient +} + +// NewMockChainInfoLightClient creates a new mock instance. +func NewMockChainInfoLightClient(ctrl *gomock.Controller) *MockChainInfoLightClient { + mock := &MockChainInfoLightClient{ctrl: ctrl} + mock.recorder = &MockChainInfoLightClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChainInfoLightClient) EXPECT() *MockChainInfoLightClientMockRecorder { + return m.recorder +} + +// AverageBlockTime mocks base method. +func (m *MockChainInfoLightClient) AverageBlockTime() time.Duration { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AverageBlockTime") + ret0, _ := ret[0].(time.Duration) + return ret0 +} + +// AverageBlockTime indicates an expected call of AverageBlockTime. +func (mr *MockChainInfoLightClientMockRecorder) AverageBlockTime() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainInfoLightClient)(nil).AverageBlockTime)) +} + +// ChainID mocks base method. +func (m *MockChainInfoLightClient) ChainID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChainID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ChainID indicates an expected call of ChainID. +func (mr *MockChainInfoLightClientMockRecorder) ChainID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainInfoLightClient)(nil).ChainID)) +} + +// CheckRefreshRequired mocks base method. +func (m *MockChainInfoLightClient) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. +func (mr *MockChainInfoLightClientMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockChainInfoLightClient)(nil).CheckRefreshRequired), ctx, counterparty) +} + +// CreateInitialLightClientState mocks base method. +func (m *MockChainInfoLightClient) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) + ret0, _ := ret[0].(exported.ClientState) + ret1, _ := ret[1].(exported.ConsensusState) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. +func (mr *MockChainInfoLightClientMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockChainInfoLightClient)(nil).CreateInitialLightClientState), ctx, height) +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockChainInfoLightClient) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockChainInfoLightClientMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockChainInfoLightClient)(nil).GetLatestFinalizedHeader), ctx) +} + +// LatestHeight mocks base method. +func (m *MockChainInfoLightClient) LatestHeight(ctx context.Context) (exported.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LatestHeight", ctx) + ret0, _ := ret[0].(exported.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LatestHeight indicates an expected call of LatestHeight. +func (mr *MockChainInfoLightClientMockRecorder) LatestHeight(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainInfoLightClient)(nil).LatestHeight), ctx) +} + +// SetupHeadersForUpdate mocks base method. +func (m *MockChainInfoLightClient) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. +func (mr *MockChainInfoLightClientMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockChainInfoLightClient)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) +} + +// Timestamp mocks base method. +func (m *MockChainInfoLightClient) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Timestamp", ctx, height) + ret0, _ := ret[0].(time.Time) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Timestamp indicates an expected call of Timestamp. +func (mr *MockChainInfoLightClientMockRecorder) Timestamp(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainInfoLightClient)(nil).Timestamp), ctx, height) +} + +// MockChainLightClient is a mock of ChainLightClient interface. +type MockChainLightClient struct { + ctrl *gomock.Controller + recorder *MockChainLightClientMockRecorder + isgomock struct{} +} + +// MockChainLightClientMockRecorder is the mock recorder for MockChainLightClient. +type MockChainLightClientMockRecorder struct { + mock *MockChainLightClient +} + +// NewMockChainLightClient creates a new mock instance. +func NewMockChainLightClient(ctrl *gomock.Controller) *MockChainLightClient { + mock := &MockChainLightClient{ctrl: ctrl} + mock.recorder = &MockChainLightClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChainLightClient) EXPECT() *MockChainLightClientMockRecorder { + return m.recorder +} + +// AverageBlockTime mocks base method. +func (m *MockChainLightClient) AverageBlockTime() time.Duration { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AverageBlockTime") + ret0, _ := ret[0].(time.Duration) + return ret0 +} + +// AverageBlockTime indicates an expected call of AverageBlockTime. +func (mr *MockChainLightClientMockRecorder) AverageBlockTime() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainLightClient)(nil).AverageBlockTime)) +} + +// ChainID mocks base method. +func (m *MockChainLightClient) ChainID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChainID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ChainID indicates an expected call of ChainID. +func (mr *MockChainLightClientMockRecorder) ChainID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainLightClient)(nil).ChainID)) +} + +// CheckRefreshRequired mocks base method. +func (m *MockChainLightClient) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. +func (mr *MockChainLightClientMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockChainLightClient)(nil).CheckRefreshRequired), ctx, counterparty) +} + +// Codec mocks base method. +func (m *MockChainLightClient) Codec() codec.ProtoCodecMarshaler { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Codec") + ret0, _ := ret[0].(codec.ProtoCodecMarshaler) + return ret0 +} + +// Codec indicates an expected call of Codec. +func (mr *MockChainLightClientMockRecorder) Codec() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Codec", reflect.TypeOf((*MockChainLightClient)(nil).Codec)) +} + +// CreateInitialLightClientState mocks base method. +func (m *MockChainLightClient) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) + ret0, _ := ret[0].(exported.ClientState) + ret1, _ := ret[1].(exported.ConsensusState) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. +func (mr *MockChainLightClientMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockChainLightClient)(nil).CreateInitialLightClientState), ctx, height) +} + +// GetAddress mocks base method. +func (m *MockChainLightClient) GetAddress() (types.AccAddress, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAddress") + ret0, _ := ret[0].(types.AccAddress) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAddress indicates an expected call of GetAddress. +func (mr *MockChainLightClientMockRecorder) GetAddress() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockChainLightClient)(nil).GetAddress)) +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockChainLightClient) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockChainLightClientMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockChainLightClient)(nil).GetLatestFinalizedHeader), ctx) +} + +// GetMsgResult mocks base method. +func (m *MockChainLightClient) GetMsgResult(ctx context.Context, id MsgID) (MsgResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMsgResult", ctx, id) + ret0, _ := ret[0].(MsgResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMsgResult indicates an expected call of GetMsgResult. +func (mr *MockChainLightClientMockRecorder) GetMsgResult(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMsgResult", reflect.TypeOf((*MockChainLightClient)(nil).GetMsgResult), ctx, id) +} + +// Init mocks base method. +func (m *MockChainLightClient) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) + ret0, _ := ret[0].(error) + return ret0 +} + +// Init indicates an expected call of Init. +func (mr *MockChainLightClientMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockChainLightClient)(nil).Init), homePath, timeout, codec, debug) +} + +// LatestHeight mocks base method. +func (m *MockChainLightClient) LatestHeight(ctx context.Context) (exported.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LatestHeight", ctx) + ret0, _ := ret[0].(exported.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LatestHeight indicates an expected call of LatestHeight. +func (mr *MockChainLightClientMockRecorder) LatestHeight(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainLightClient)(nil).LatestHeight), ctx) +} + +// Path mocks base method. +func (m *MockChainLightClient) Path() *PathEnd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Path") + ret0, _ := ret[0].(*PathEnd) + return ret0 +} + +// Path indicates an expected call of Path. +func (mr *MockChainLightClientMockRecorder) Path() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockChainLightClient)(nil).Path)) +} + +// QueryBalance mocks base method. +func (m *MockChainLightClient) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryBalance", ctx, address) + ret0, _ := ret[0].(types.Coins) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryBalance indicates an expected call of QueryBalance. +func (mr *MockChainLightClientMockRecorder) QueryBalance(ctx, address any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockChainLightClient)(nil).QueryBalance), ctx, address) +} + +// QueryCanTransitionToFlushComplete mocks base method. +func (m *MockChainLightClient) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. +func (mr *MockChainLightClientMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockChainLightClient)(nil).QueryCanTransitionToFlushComplete), ctx) +} + +// QueryChannel mocks base method. +func (m *MockChainLightClient) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannel", ctx) + ret0, _ := ret[0].(*types3.QueryChannelResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannel indicates an expected call of QueryChannel. +func (mr *MockChainLightClientMockRecorder) QueryChannel(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockChainLightClient)(nil).QueryChannel), ctx) +} + +// QueryChannelUpgrade mocks base method. +func (m *MockChainLightClient) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. +func (mr *MockChainLightClientMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockChainLightClient)(nil).QueryChannelUpgrade), ctx) +} + +// QueryChannelUpgradeError mocks base method. +func (m *MockChainLightClient) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. +func (mr *MockChainLightClientMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockChainLightClient)(nil).QueryChannelUpgradeError), ctx) +} + +// QueryClientConsensusState mocks base method. +func (m *MockChainLightClient) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) + ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. +func (mr *MockChainLightClientMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockChainLightClient)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) +} + +// QueryClientState mocks base method. +func (m *MockChainLightClient) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientState", ctx) + ret0, _ := ret[0].(*types1.QueryClientStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientState indicates an expected call of QueryClientState. +func (mr *MockChainLightClientMockRecorder) QueryClientState(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockChainLightClient)(nil).QueryClientState), ctx) +} + +// QueryConnection mocks base method. +func (m *MockChainLightClient) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) + ret0, _ := ret[0].(*types2.QueryConnectionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryConnection indicates an expected call of QueryConnection. +func (mr *MockChainLightClientMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockChainLightClient)(nil).QueryConnection), ctx, connectionID) +} + +// QueryDenomTraces mocks base method. +func (m *MockChainLightClient) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) + ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryDenomTraces indicates an expected call of QueryDenomTraces. +func (mr *MockChainLightClientMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockChainLightClient)(nil).QueryDenomTraces), ctx, offset, limit) +} + +// QueryNextSequenceReceive mocks base method. +func (m *MockChainLightClient) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockChainLightClientMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockChainLightClient)(nil).QueryNextSequenceReceive), ctx) +} + +// QueryUnfinalizedRelayAcknowledgements mocks base method. +func (m *MockChainLightClient) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. +func (mr *MockChainLightClientMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) +} + +// QueryUnfinalizedRelayPackets mocks base method. +func (m *MockChainLightClient) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. +func (mr *MockChainLightClientMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) +} + +// QueryUnreceivedAcknowledgements mocks base method. +func (m *MockChainLightClient) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. +func (mr *MockChainLightClientMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) +} + +// QueryUnreceivedPackets mocks base method. +func (m *MockChainLightClient) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. +func (mr *MockChainLightClientMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnreceivedPackets), ctx, seqs) +} + +// RegisterMsgEventListener mocks base method. +func (m *MockChainLightClient) RegisterMsgEventListener(arg0 MsgEventListener) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterMsgEventListener", arg0) +} + +// RegisterMsgEventListener indicates an expected call of RegisterMsgEventListener. +func (mr *MockChainLightClientMockRecorder) RegisterMsgEventListener(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMsgEventListener", reflect.TypeOf((*MockChainLightClient)(nil).RegisterMsgEventListener), arg0) +} + +// SendMsgs mocks base method. +func (m *MockChainLightClient) SendMsgs(ctx context.Context, msgs []types.Msg) ([]MsgID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendMsgs", ctx, msgs) + ret0, _ := ret[0].([]MsgID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMsgs indicates an expected call of SendMsgs. +func (mr *MockChainLightClientMockRecorder) SendMsgs(ctx, msgs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsgs", reflect.TypeOf((*MockChainLightClient)(nil).SendMsgs), ctx, msgs) +} + +// SetRelayInfo mocks base method. +func (m *MockChainLightClient) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRelayInfo indicates an expected call of SetRelayInfo. +func (mr *MockChainLightClientMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockChainLightClient)(nil).SetRelayInfo), path, counterparty, counterpartyPath) +} + +// SetupForRelay mocks base method. +func (m *MockChainLightClient) SetupForRelay(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupForRelay", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetupForRelay indicates an expected call of SetupForRelay. +func (mr *MockChainLightClientMockRecorder) SetupForRelay(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockChainLightClient)(nil).SetupForRelay), ctx) +} + +// SetupHeadersForUpdate mocks base method. +func (m *MockChainLightClient) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. +func (mr *MockChainLightClientMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockChainLightClient)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) +} + +// Timestamp mocks base method. +func (m *MockChainLightClient) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Timestamp", ctx, height) + ret0, _ := ret[0].(time.Time) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Timestamp indicates an expected call of Timestamp. +func (mr *MockChainLightClientMockRecorder) Timestamp(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainLightClient)(nil).Timestamp), ctx, height) +} diff --git a/core/provers_testmock.go b/core/provers_testmock.go new file mode 100644 index 00000000..218d2a85 --- /dev/null +++ b/core/provers_testmock.go @@ -0,0 +1,908 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: core/provers.go +// +// Generated by this command: +// +// mockgen -source core/provers.go -destination core/provers_testmock.go -package core +// + +// Package core is a generated GoMock package. +package core + +import ( + context "context" + reflect "reflect" + time "time" + + codec "github.com/cosmos/cosmos-sdk/codec" + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" + types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + types2 "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" + types3 "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + exported "github.com/cosmos/ibc-go/v8/modules/core/exported" + gomock "go.uber.org/mock/gomock" +) + +// MockProver is a mock of Prover interface. +type MockProver struct { + ctrl *gomock.Controller + recorder *MockProverMockRecorder + isgomock struct{} +} + +// MockProverMockRecorder is the mock recorder for MockProver. +type MockProverMockRecorder struct { + mock *MockProver +} + +// NewMockProver creates a new mock instance. +func NewMockProver(ctrl *gomock.Controller) *MockProver { + mock := &MockProver{ctrl: ctrl} + mock.recorder = &MockProverMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProver) EXPECT() *MockProverMockRecorder { + return m.recorder +} + +// CheckRefreshRequired mocks base method. +func (m *MockProver) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. +func (mr *MockProverMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockProver)(nil).CheckRefreshRequired), ctx, counterparty) +} + +// CreateInitialLightClientState mocks base method. +func (m *MockProver) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) + ret0, _ := ret[0].(exported.ClientState) + ret1, _ := ret[1].(exported.ConsensusState) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. +func (mr *MockProverMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockProver)(nil).CreateInitialLightClientState), ctx, height) +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockProver) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockProverMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockProver)(nil).GetLatestFinalizedHeader), ctx) +} + +// Init mocks base method. +func (m *MockProver) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) + ret0, _ := ret[0].(error) + return ret0 +} + +// Init indicates an expected call of Init. +func (mr *MockProverMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockProver)(nil).Init), homePath, timeout, codec, debug) +} + +// ProveHostConsensusState mocks base method. +func (m *MockProver) ProveHostConsensusState(ctx QueryContext, height exported.Height, consensusState exported.ConsensusState) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProveHostConsensusState", ctx, height, consensusState) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProveHostConsensusState indicates an expected call of ProveHostConsensusState. +func (mr *MockProverMockRecorder) ProveHostConsensusState(ctx, height, consensusState any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveHostConsensusState", reflect.TypeOf((*MockProver)(nil).ProveHostConsensusState), ctx, height, consensusState) +} + +// ProveState mocks base method. +func (m *MockProver) ProveState(ctx QueryContext, path string, value []byte) ([]byte, types1.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProveState", ctx, path, value) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(types1.Height) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ProveState indicates an expected call of ProveState. +func (mr *MockProverMockRecorder) ProveState(ctx, path, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveState", reflect.TypeOf((*MockProver)(nil).ProveState), ctx, path, value) +} + +// SetRelayInfo mocks base method. +func (m *MockProver) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRelayInfo indicates an expected call of SetRelayInfo. +func (mr *MockProverMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockProver)(nil).SetRelayInfo), path, counterparty, counterpartyPath) +} + +// SetupForRelay mocks base method. +func (m *MockProver) SetupForRelay(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupForRelay", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetupForRelay indicates an expected call of SetupForRelay. +func (mr *MockProverMockRecorder) SetupForRelay(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockProver)(nil).SetupForRelay), ctx) +} + +// SetupHeadersForUpdate mocks base method. +func (m *MockProver) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. +func (mr *MockProverMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockProver)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) +} + +// MockStateProver is a mock of StateProver interface. +type MockStateProver struct { + ctrl *gomock.Controller + recorder *MockStateProverMockRecorder + isgomock struct{} +} + +// MockStateProverMockRecorder is the mock recorder for MockStateProver. +type MockStateProverMockRecorder struct { + mock *MockStateProver +} + +// NewMockStateProver creates a new mock instance. +func NewMockStateProver(ctrl *gomock.Controller) *MockStateProver { + mock := &MockStateProver{ctrl: ctrl} + mock.recorder = &MockStateProverMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStateProver) EXPECT() *MockStateProverMockRecorder { + return m.recorder +} + +// ProveHostConsensusState mocks base method. +func (m *MockStateProver) ProveHostConsensusState(ctx QueryContext, height exported.Height, consensusState exported.ConsensusState) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProveHostConsensusState", ctx, height, consensusState) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProveHostConsensusState indicates an expected call of ProveHostConsensusState. +func (mr *MockStateProverMockRecorder) ProveHostConsensusState(ctx, height, consensusState any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveHostConsensusState", reflect.TypeOf((*MockStateProver)(nil).ProveHostConsensusState), ctx, height, consensusState) +} + +// ProveState mocks base method. +func (m *MockStateProver) ProveState(ctx QueryContext, path string, value []byte) ([]byte, types1.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProveState", ctx, path, value) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(types1.Height) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ProveState indicates an expected call of ProveState. +func (mr *MockStateProverMockRecorder) ProveState(ctx, path, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveState", reflect.TypeOf((*MockStateProver)(nil).ProveState), ctx, path, value) +} + +// MockLightClient is a mock of LightClient interface. +type MockLightClient struct { + ctrl *gomock.Controller + recorder *MockLightClientMockRecorder + isgomock struct{} +} + +// MockLightClientMockRecorder is the mock recorder for MockLightClient. +type MockLightClientMockRecorder struct { + mock *MockLightClient +} + +// NewMockLightClient creates a new mock instance. +func NewMockLightClient(ctrl *gomock.Controller) *MockLightClient { + mock := &MockLightClient{ctrl: ctrl} + mock.recorder = &MockLightClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLightClient) EXPECT() *MockLightClientMockRecorder { + return m.recorder +} + +// CheckRefreshRequired mocks base method. +func (m *MockLightClient) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. +func (mr *MockLightClientMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockLightClient)(nil).CheckRefreshRequired), ctx, counterparty) +} + +// CreateInitialLightClientState mocks base method. +func (m *MockLightClient) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) + ret0, _ := ret[0].(exported.ClientState) + ret1, _ := ret[1].(exported.ConsensusState) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. +func (mr *MockLightClientMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockLightClient)(nil).CreateInitialLightClientState), ctx, height) +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockLightClient) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockLightClientMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockLightClient)(nil).GetLatestFinalizedHeader), ctx) +} + +// SetupHeadersForUpdate mocks base method. +func (m *MockLightClient) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) + ret0, _ := ret[0].([]Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. +func (mr *MockLightClientMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockLightClient)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) +} + +// MockFinalityAware is a mock of FinalityAware interface. +type MockFinalityAware struct { + ctrl *gomock.Controller + recorder *MockFinalityAwareMockRecorder + isgomock struct{} +} + +// MockFinalityAwareMockRecorder is the mock recorder for MockFinalityAware. +type MockFinalityAwareMockRecorder struct { + mock *MockFinalityAware +} + +// NewMockFinalityAware creates a new mock instance. +func NewMockFinalityAware(ctrl *gomock.Controller) *MockFinalityAware { + mock := &MockFinalityAware{ctrl: ctrl} + mock.recorder = &MockFinalityAwareMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockFinalityAware) EXPECT() *MockFinalityAwareMockRecorder { + return m.recorder +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockFinalityAware) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockFinalityAwareMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockFinalityAware)(nil).GetLatestFinalizedHeader), ctx) +} + +// MockFinalityAwareChain is a mock of FinalityAwareChain interface. +type MockFinalityAwareChain struct { + ctrl *gomock.Controller + recorder *MockFinalityAwareChainMockRecorder + isgomock struct{} +} + +// MockFinalityAwareChainMockRecorder is the mock recorder for MockFinalityAwareChain. +type MockFinalityAwareChainMockRecorder struct { + mock *MockFinalityAwareChain +} + +// NewMockFinalityAwareChain creates a new mock instance. +func NewMockFinalityAwareChain(ctrl *gomock.Controller) *MockFinalityAwareChain { + mock := &MockFinalityAwareChain{ctrl: ctrl} + mock.recorder = &MockFinalityAwareChainMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockFinalityAwareChain) EXPECT() *MockFinalityAwareChainMockRecorder { + return m.recorder +} + +// AverageBlockTime mocks base method. +func (m *MockFinalityAwareChain) AverageBlockTime() time.Duration { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AverageBlockTime") + ret0, _ := ret[0].(time.Duration) + return ret0 +} + +// AverageBlockTime indicates an expected call of AverageBlockTime. +func (mr *MockFinalityAwareChainMockRecorder) AverageBlockTime() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockFinalityAwareChain)(nil).AverageBlockTime)) +} + +// ChainID mocks base method. +func (m *MockFinalityAwareChain) ChainID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChainID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ChainID indicates an expected call of ChainID. +func (mr *MockFinalityAwareChainMockRecorder) ChainID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockFinalityAwareChain)(nil).ChainID)) +} + +// Codec mocks base method. +func (m *MockFinalityAwareChain) Codec() codec.ProtoCodecMarshaler { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Codec") + ret0, _ := ret[0].(codec.ProtoCodecMarshaler) + return ret0 +} + +// Codec indicates an expected call of Codec. +func (mr *MockFinalityAwareChainMockRecorder) Codec() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Codec", reflect.TypeOf((*MockFinalityAwareChain)(nil).Codec)) +} + +// GetAddress mocks base method. +func (m *MockFinalityAwareChain) GetAddress() (types.AccAddress, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAddress") + ret0, _ := ret[0].(types.AccAddress) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAddress indicates an expected call of GetAddress. +func (mr *MockFinalityAwareChainMockRecorder) GetAddress() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockFinalityAwareChain)(nil).GetAddress)) +} + +// GetLatestFinalizedHeader mocks base method. +func (m *MockFinalityAwareChain) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) + ret0, _ := ret[0].(Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. +func (mr *MockFinalityAwareChainMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockFinalityAwareChain)(nil).GetLatestFinalizedHeader), ctx) +} + +// GetMsgResult mocks base method. +func (m *MockFinalityAwareChain) GetMsgResult(ctx context.Context, id MsgID) (MsgResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMsgResult", ctx, id) + ret0, _ := ret[0].(MsgResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMsgResult indicates an expected call of GetMsgResult. +func (mr *MockFinalityAwareChainMockRecorder) GetMsgResult(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMsgResult", reflect.TypeOf((*MockFinalityAwareChain)(nil).GetMsgResult), ctx, id) +} + +// Init mocks base method. +func (m *MockFinalityAwareChain) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) + ret0, _ := ret[0].(error) + return ret0 +} + +// Init indicates an expected call of Init. +func (mr *MockFinalityAwareChainMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockFinalityAwareChain)(nil).Init), homePath, timeout, codec, debug) +} + +// LatestHeight mocks base method. +func (m *MockFinalityAwareChain) LatestHeight(ctx context.Context) (exported.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LatestHeight", ctx) + ret0, _ := ret[0].(exported.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LatestHeight indicates an expected call of LatestHeight. +func (mr *MockFinalityAwareChainMockRecorder) LatestHeight(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockFinalityAwareChain)(nil).LatestHeight), ctx) +} + +// Path mocks base method. +func (m *MockFinalityAwareChain) Path() *PathEnd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Path") + ret0, _ := ret[0].(*PathEnd) + return ret0 +} + +// Path indicates an expected call of Path. +func (mr *MockFinalityAwareChainMockRecorder) Path() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockFinalityAwareChain)(nil).Path)) +} + +// QueryBalance mocks base method. +func (m *MockFinalityAwareChain) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryBalance", ctx, address) + ret0, _ := ret[0].(types.Coins) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryBalance indicates an expected call of QueryBalance. +func (mr *MockFinalityAwareChainMockRecorder) QueryBalance(ctx, address any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryBalance), ctx, address) +} + +// QueryCanTransitionToFlushComplete mocks base method. +func (m *MockFinalityAwareChain) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. +func (mr *MockFinalityAwareChainMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryCanTransitionToFlushComplete), ctx) +} + +// QueryChannel mocks base method. +func (m *MockFinalityAwareChain) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannel", ctx) + ret0, _ := ret[0].(*types3.QueryChannelResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannel indicates an expected call of QueryChannel. +func (mr *MockFinalityAwareChainMockRecorder) QueryChannel(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryChannel), ctx) +} + +// QueryChannelUpgrade mocks base method. +func (m *MockFinalityAwareChain) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. +func (mr *MockFinalityAwareChainMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryChannelUpgrade), ctx) +} + +// QueryChannelUpgradeError mocks base method. +func (m *MockFinalityAwareChain) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) + ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. +func (mr *MockFinalityAwareChainMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryChannelUpgradeError), ctx) +} + +// QueryClientConsensusState mocks base method. +func (m *MockFinalityAwareChain) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) + ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. +func (mr *MockFinalityAwareChainMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) +} + +// QueryClientState mocks base method. +func (m *MockFinalityAwareChain) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientState", ctx) + ret0, _ := ret[0].(*types1.QueryClientStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientState indicates an expected call of QueryClientState. +func (mr *MockFinalityAwareChainMockRecorder) QueryClientState(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryClientState), ctx) +} + +// QueryConnection mocks base method. +func (m *MockFinalityAwareChain) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) + ret0, _ := ret[0].(*types2.QueryConnectionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryConnection indicates an expected call of QueryConnection. +func (mr *MockFinalityAwareChainMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryConnection), ctx, connectionID) +} + +// QueryDenomTraces mocks base method. +func (m *MockFinalityAwareChain) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) + ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryDenomTraces indicates an expected call of QueryDenomTraces. +func (mr *MockFinalityAwareChainMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryDenomTraces), ctx, offset, limit) +} + +// QueryNextSequenceReceive mocks base method. +func (m *MockFinalityAwareChain) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockFinalityAwareChainMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryNextSequenceReceive), ctx) +} + +// QueryUnfinalizedRelayAcknowledgements mocks base method. +func (m *MockFinalityAwareChain) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. +func (mr *MockFinalityAwareChainMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) +} + +// QueryUnfinalizedRelayPackets mocks base method. +func (m *MockFinalityAwareChain) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) + ret0, _ := ret[0].(PacketInfoList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. +func (mr *MockFinalityAwareChainMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) +} + +// QueryUnreceivedAcknowledgements mocks base method. +func (m *MockFinalityAwareChain) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. +func (mr *MockFinalityAwareChainMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) +} + +// QueryUnreceivedPackets mocks base method. +func (m *MockFinalityAwareChain) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) + ret0, _ := ret[0].([]uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. +func (mr *MockFinalityAwareChainMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnreceivedPackets), ctx, seqs) +} + +// RegisterMsgEventListener mocks base method. +func (m *MockFinalityAwareChain) RegisterMsgEventListener(arg0 MsgEventListener) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterMsgEventListener", arg0) +} + +// RegisterMsgEventListener indicates an expected call of RegisterMsgEventListener. +func (mr *MockFinalityAwareChainMockRecorder) RegisterMsgEventListener(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMsgEventListener", reflect.TypeOf((*MockFinalityAwareChain)(nil).RegisterMsgEventListener), arg0) +} + +// SendMsgs mocks base method. +func (m *MockFinalityAwareChain) SendMsgs(ctx context.Context, msgs []types.Msg) ([]MsgID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendMsgs", ctx, msgs) + ret0, _ := ret[0].([]MsgID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMsgs indicates an expected call of SendMsgs. +func (mr *MockFinalityAwareChainMockRecorder) SendMsgs(ctx, msgs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsgs", reflect.TypeOf((*MockFinalityAwareChain)(nil).SendMsgs), ctx, msgs) +} + +// SetRelayInfo mocks base method. +func (m *MockFinalityAwareChain) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRelayInfo indicates an expected call of SetRelayInfo. +func (mr *MockFinalityAwareChainMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockFinalityAwareChain)(nil).SetRelayInfo), path, counterparty, counterpartyPath) +} + +// SetupForRelay mocks base method. +func (m *MockFinalityAwareChain) SetupForRelay(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupForRelay", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetupForRelay indicates an expected call of SetupForRelay. +func (mr *MockFinalityAwareChainMockRecorder) SetupForRelay(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockFinalityAwareChain)(nil).SetupForRelay), ctx) +} + +// Timestamp mocks base method. +func (m *MockFinalityAwareChain) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Timestamp", ctx, height) + ret0, _ := ret[0].(time.Time) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Timestamp indicates an expected call of Timestamp. +func (mr *MockFinalityAwareChainMockRecorder) Timestamp(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockFinalityAwareChain)(nil).Timestamp), ctx, height) +} + +// MockChainInfoICS02Querier is a mock of ChainInfoICS02Querier interface. +type MockChainInfoICS02Querier struct { + ctrl *gomock.Controller + recorder *MockChainInfoICS02QuerierMockRecorder + isgomock struct{} +} + +// MockChainInfoICS02QuerierMockRecorder is the mock recorder for MockChainInfoICS02Querier. +type MockChainInfoICS02QuerierMockRecorder struct { + mock *MockChainInfoICS02Querier +} + +// NewMockChainInfoICS02Querier creates a new mock instance. +func NewMockChainInfoICS02Querier(ctrl *gomock.Controller) *MockChainInfoICS02Querier { + mock := &MockChainInfoICS02Querier{ctrl: ctrl} + mock.recorder = &MockChainInfoICS02QuerierMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChainInfoICS02Querier) EXPECT() *MockChainInfoICS02QuerierMockRecorder { + return m.recorder +} + +// AverageBlockTime mocks base method. +func (m *MockChainInfoICS02Querier) AverageBlockTime() time.Duration { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AverageBlockTime") + ret0, _ := ret[0].(time.Duration) + return ret0 +} + +// AverageBlockTime indicates an expected call of AverageBlockTime. +func (mr *MockChainInfoICS02QuerierMockRecorder) AverageBlockTime() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).AverageBlockTime)) +} + +// ChainID mocks base method. +func (m *MockChainInfoICS02Querier) ChainID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChainID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ChainID indicates an expected call of ChainID. +func (mr *MockChainInfoICS02QuerierMockRecorder) ChainID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).ChainID)) +} + +// LatestHeight mocks base method. +func (m *MockChainInfoICS02Querier) LatestHeight(ctx context.Context) (exported.Height, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LatestHeight", ctx) + ret0, _ := ret[0].(exported.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LatestHeight indicates an expected call of LatestHeight. +func (mr *MockChainInfoICS02QuerierMockRecorder) LatestHeight(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).LatestHeight), ctx) +} + +// QueryClientConsensusState mocks base method. +func (m *MockChainInfoICS02Querier) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) + ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. +func (mr *MockChainInfoICS02QuerierMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) +} + +// QueryClientState mocks base method. +func (m *MockChainInfoICS02Querier) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryClientState", ctx) + ret0, _ := ret[0].(*types1.QueryClientStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryClientState indicates an expected call of QueryClientState. +func (mr *MockChainInfoICS02QuerierMockRecorder) QueryClientState(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).QueryClientState), ctx) +} + +// Timestamp mocks base method. +func (m *MockChainInfoICS02Querier) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Timestamp", ctx, height) + ret0, _ := ret[0].(time.Time) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Timestamp indicates an expected call of Timestamp. +func (mr *MockChainInfoICS02QuerierMockRecorder) Timestamp(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).Timestamp), ctx, height) +} diff --git a/core/service_test.go b/core/service_test.go new file mode 100644 index 00000000..19d3b93b --- /dev/null +++ b/core/service_test.go @@ -0,0 +1,86 @@ +package core + +import ( + "testing" + "go.uber.org/mock/gomock" + + "time" + "context" + "os" + "github.com/hyperledger-labs/yui-relayer/log" +) + +func TestServe(t *testing.T) { + log.InitLoggerWithWriter("debug", "text", os.Stdout) + + ctrl := gomock.NewController(t) + + st := NewMockStrategyI(ctrl) + sh := NewMockSyncHeaders(ctrl) + srcChain := NewMockChain(ctrl) + srcProver := NewMockProver(ctrl) + dstChain := NewMockChain(ctrl) + dstProver := NewMockProver(ctrl) + + src := NewProvableChain(srcChain, srcProver) + dst := NewProvableChain(dstChain, dstProver) + srv := NewRelayService(st, src, dst, sh, time.Minute, time.Minute, 3, time.Minute, 3) + + srcChain.EXPECT().ChainID().Return("srcChain").AnyTimes() + srcChain.EXPECT().Path().Return(&PathEnd{ + ChainID: "srcChain", + ClientID: "srcClient", + ConnectionID: "srcConn", + ChannelID: "srcChan", + PortID: "srcPort", + Order: "ORDERED", + Version: "srcVersion", + }).AnyTimes() + + dstChain.EXPECT().ChainID().Return("dstChain").AnyTimes() + dstChain.EXPECT().Path().Return(&PathEnd{ + ChainID: "dstChain", + ClientID: "dstClient", + ConnectionID: "dstConn", + ChannelID: "dstChan", + PortID: "dstPort", + Order: "ORDERED", + Version: "dstVersion", + }).AnyTimes() + + sh.EXPECT().Updates(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + + st.EXPECT().UnrelayedPackets(gomock.Any(), gomock.Any(), gomock.Any(), false).Return( + &RelayPackets{ + Src: []*PacketInfo{ + }, + Dst: []*PacketInfo{ + }, + }, nil, + ) + + st.EXPECT().UnrelayedAcknowledgements(gomock.Any(), gomock.Any(), gomock.Any(), false).Return( + &RelayPackets{ + Src: []*PacketInfo{ + }, + Dst: []*PacketInfo{ + }, + }, nil, + ) + + st.EXPECT().UpdateClients(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), true).Return( + NewRelayMsgs(), nil, + ) + + st.EXPECT().RelayPackets(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return( + NewRelayMsgs(), nil, + ) + + st.EXPECT().RelayAcknowledgements(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return( + NewRelayMsgs(), nil, + ) + + st.EXPECT().Send(gomock.Any(), gomock.Any(), gomock.Any()) + + srv.Serve(context.TODO()) +} diff --git a/core/strategies_testmock.go b/core/strategies_testmock.go new file mode 100644 index 00000000..e01f8fcf --- /dev/null +++ b/core/strategies_testmock.go @@ -0,0 +1,156 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: core/strategies.go +// +// Generated by this command: +// +// mockgen -source core/strategies.go -destination core/strategies_testmock.go -package core +// + +// Package core is a generated GoMock package. +package core + +import ( + context "context" + reflect "reflect" + + gomock "go.uber.org/mock/gomock" +) + +// MockStrategyI is a mock of StrategyI interface. +type MockStrategyI struct { + ctrl *gomock.Controller + recorder *MockStrategyIMockRecorder + isgomock struct{} +} + +// MockStrategyIMockRecorder is the mock recorder for MockStrategyI. +type MockStrategyIMockRecorder struct { + mock *MockStrategyI +} + +// NewMockStrategyI creates a new mock instance. +func NewMockStrategyI(ctrl *gomock.Controller) *MockStrategyI { + mock := &MockStrategyI{ctrl: ctrl} + mock.recorder = &MockStrategyIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStrategyI) EXPECT() *MockStrategyIMockRecorder { + return m.recorder +} + +// GetType mocks base method. +func (m *MockStrategyI) GetType() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetType") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetType indicates an expected call of GetType. +func (mr *MockStrategyIMockRecorder) GetType() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetType", reflect.TypeOf((*MockStrategyI)(nil).GetType)) +} + +// RelayAcknowledgements mocks base method. +func (m *MockStrategyI) RelayAcknowledgements(src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*RelayMsgs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RelayAcknowledgements", src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) + ret0, _ := ret[0].(*RelayMsgs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RelayAcknowledgements indicates an expected call of RelayAcknowledgements. +func (mr *MockStrategyIMockRecorder) RelayAcknowledgements(src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RelayAcknowledgements", reflect.TypeOf((*MockStrategyI)(nil).RelayAcknowledgements), src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) +} + +// RelayPackets mocks base method. +func (m *MockStrategyI) RelayPackets(src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*RelayMsgs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RelayPackets", src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) + ret0, _ := ret[0].(*RelayMsgs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RelayPackets indicates an expected call of RelayPackets. +func (mr *MockStrategyIMockRecorder) RelayPackets(src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RelayPackets", reflect.TypeOf((*MockStrategyI)(nil).RelayPackets), src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) +} + +// Send mocks base method. +func (m *MockStrategyI) Send(src, dst Chain, msgs *RelayMsgs) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Send", src, dst, msgs) +} + +// Send indicates an expected call of Send. +func (mr *MockStrategyIMockRecorder) Send(src, dst, msgs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockStrategyI)(nil).Send), src, dst, msgs) +} + +// SetupRelay mocks base method. +func (m *MockStrategyI) SetupRelay(ctx context.Context, src, dst *ProvableChain) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetupRelay", ctx, src, dst) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetupRelay indicates an expected call of SetupRelay. +func (mr *MockStrategyIMockRecorder) SetupRelay(ctx, src, dst any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupRelay", reflect.TypeOf((*MockStrategyI)(nil).SetupRelay), ctx, src, dst) +} + +// UnrelayedAcknowledgements mocks base method. +func (m *MockStrategyI) UnrelayedAcknowledgements(src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnrelayedAcknowledgements", src, dst, sh, includeRelayedButUnfinalized) + ret0, _ := ret[0].(*RelayPackets) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnrelayedAcknowledgements indicates an expected call of UnrelayedAcknowledgements. +func (mr *MockStrategyIMockRecorder) UnrelayedAcknowledgements(src, dst, sh, includeRelayedButUnfinalized any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrelayedAcknowledgements", reflect.TypeOf((*MockStrategyI)(nil).UnrelayedAcknowledgements), src, dst, sh, includeRelayedButUnfinalized) +} + +// UnrelayedPackets mocks base method. +func (m *MockStrategyI) UnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnrelayedPackets", src, dst, sh, includeRelayedButUnfinalized) + ret0, _ := ret[0].(*RelayPackets) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnrelayedPackets indicates an expected call of UnrelayedPackets. +func (mr *MockStrategyIMockRecorder) UnrelayedPackets(src, dst, sh, includeRelayedButUnfinalized any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrelayedPackets", reflect.TypeOf((*MockStrategyI)(nil).UnrelayedPackets), src, dst, sh, includeRelayedButUnfinalized) +} + +// UpdateClients mocks base method. +func (m *MockStrategyI) UpdateClients(src, dst *ProvableChain, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst bool, sh SyncHeaders, doRefresh bool) (*RelayMsgs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClients", src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) + ret0, _ := ret[0].(*RelayMsgs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateClients indicates an expected call of UpdateClients. +func (mr *MockStrategyIMockRecorder) UpdateClients(src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClients", reflect.TypeOf((*MockStrategyI)(nil).UpdateClients), src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) +} diff --git a/go.mod b/go.mod index bcc2bc8c..52b1d523 100644 --- a/go.mod +++ b/go.mod @@ -25,6 +25,7 @@ require ( go.opentelemetry.io/otel/exporters/prometheus v0.55.0 go.opentelemetry.io/otel/metric v1.33.0 go.opentelemetry.io/otel/sdk/metric v1.33.0 + go.uber.org/mock v0.5.0 golang.org/x/sync v0.10.0 google.golang.org/grpc v1.62.0 gopkg.in/yaml.v2 v2.4.0 diff --git a/go.sum b/go.sum index 8b009e9f..c4f2cedf 100644 --- a/go.sum +++ b/go.sum @@ -1077,6 +1077,8 @@ go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= +go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= From 906776eadc34e266f136e098a9353a6a7cecadbb Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Thu, 13 Mar 2025 02:41:37 +0000 Subject: [PATCH 02/14] add service_test Signed-off-by: Daisuke Kanda --- Makefile | 4 +- core/chain.go | 1 + core/chain_testmock.go | 64 +-- core/headers_testmock.go | 849 --------------------------------- core/provers.go | 6 +- core/provers_testmock.go | 908 ------------------------------------ core/service_test.go | 261 ++++++++--- core/strategies_testmock.go | 156 ------- 8 files changed, 211 insertions(+), 2038 deletions(-) delete mode 100644 core/headers_testmock.go delete mode 100644 core/provers_testmock.go delete mode 100644 core/strategies_testmock.go diff --git a/Makefile b/Makefile index 7cc724f8..e361e6d1 100644 --- a/Makefile +++ b/Makefile @@ -8,7 +8,7 @@ protoImage=$(DOCKER) run --user 0 --rm -v $(CURDIR):/workspace --workdir /worksp build: go build -o ./build/yrly . -TESTMOCKS = core/strategies_testmock.go core/provers_testmock.go core/chain_testmock.go core/headers_testmock.go +TESTMOCKS = core/chain_testmock.go .PHONY: test test: $(TESTMOCKS) go test -v ./... @@ -21,6 +21,6 @@ proto-update-deps: @echo "Updating Protobuf dependencies" $(TESTMOCKS): - for f in $@; do mockgen -source `echo $$f | sed -e s/_testmock//g` -destination $$f -package core; done + go generate ./... .PHONY: proto-gen proto-update-deps diff --git a/core/chain.go b/core/chain.go index 43ecb033..fcbf0a91 100644 --- a/core/chain.go +++ b/core/chain.go @@ -55,6 +55,7 @@ func (pc *ProvableChain) SetupForRelay(ctx context.Context) error { return nil } +//go:generate mockgen -source=chain.go -destination=chain_testmock.go -package core // Chain represents a chain that supports sending transactions and querying the state type Chain interface { // GetAddress returns the address of relayer diff --git a/core/chain_testmock.go b/core/chain_testmock.go index 50cff53f..f4cae451 100644 --- a/core/chain_testmock.go +++ b/core/chain_testmock.go @@ -1,9 +1,9 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: core/chain.go +// Source: chain.go // // Generated by this command: // -// mockgen -source core/chain.go -destination core/chain_testmock.go -package core +// mockgen -source=chain.go -destination=chain_testmock.go -package core // // Package core is a generated GoMock package. @@ -298,21 +298,6 @@ func (mr *MockChainMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockChain)(nil).QueryDenomTraces), ctx, offset, limit) } -// QueryNextSequenceReceive mocks base method. -func (m *MockChain) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockChainMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockChain)(nil).QueryNextSequenceReceive), ctx) -} - // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockChain) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() @@ -692,21 +677,6 @@ func (mr *MockIBCQuerierMockRecorder) QueryConnection(ctx, connectionID any) *go return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockIBCQuerier)(nil).QueryConnection), ctx, connectionID) } -// QueryNextSequenceReceive mocks base method. -func (m *MockIBCQuerier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockIBCQuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockIBCQuerier)(nil).QueryNextSequenceReceive), ctx) -} - // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockIBCQuerier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() @@ -944,21 +914,6 @@ func (mr *MockICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannelUpgradeError), ctx) } -// QueryNextSequenceReceive mocks base method. -func (m *MockICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockICS04Querier)(nil).QueryNextSequenceReceive), ctx) -} - // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() @@ -1203,21 +1158,6 @@ func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannelUpgradeError), ctx) } -// QueryNextSequenceReceive mocks base method. -func (m *MockLightClientICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryNextSequenceReceive), ctx) -} - // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockLightClientICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() diff --git a/core/headers_testmock.go b/core/headers_testmock.go deleted file mode 100644 index 6c43ba28..00000000 --- a/core/headers_testmock.go +++ /dev/null @@ -1,849 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: core/headers.go -// -// Generated by this command: -// -// mockgen -source core/headers.go -destination core/headers_testmock.go -package core -// - -// Package core is a generated GoMock package. -package core - -import ( - context "context" - reflect "reflect" - time "time" - - codec "github.com/cosmos/cosmos-sdk/codec" - types "github.com/cosmos/cosmos-sdk/types" - types0 "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" - types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" - types2 "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" - types3 "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" - exported "github.com/cosmos/ibc-go/v8/modules/core/exported" - gomock "go.uber.org/mock/gomock" -) - -// MockHeader is a mock of Header interface. -type MockHeader struct { - ctrl *gomock.Controller - recorder *MockHeaderMockRecorder - isgomock struct{} -} - -// MockHeaderMockRecorder is the mock recorder for MockHeader. -type MockHeaderMockRecorder struct { - mock *MockHeader -} - -// NewMockHeader creates a new mock instance. -func NewMockHeader(ctrl *gomock.Controller) *MockHeader { - mock := &MockHeader{ctrl: ctrl} - mock.recorder = &MockHeaderMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockHeader) EXPECT() *MockHeaderMockRecorder { - return m.recorder -} - -// ClientType mocks base method. -func (m *MockHeader) ClientType() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ClientType") - ret0, _ := ret[0].(string) - return ret0 -} - -// ClientType indicates an expected call of ClientType. -func (mr *MockHeaderMockRecorder) ClientType() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientType", reflect.TypeOf((*MockHeader)(nil).ClientType)) -} - -// GetHeight mocks base method. -func (m *MockHeader) GetHeight() exported.Height { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetHeight") - ret0, _ := ret[0].(exported.Height) - return ret0 -} - -// GetHeight indicates an expected call of GetHeight. -func (mr *MockHeaderMockRecorder) GetHeight() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeight", reflect.TypeOf((*MockHeader)(nil).GetHeight)) -} - -// ProtoMessage mocks base method. -func (m *MockHeader) ProtoMessage() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "ProtoMessage") -} - -// ProtoMessage indicates an expected call of ProtoMessage. -func (mr *MockHeaderMockRecorder) ProtoMessage() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProtoMessage", reflect.TypeOf((*MockHeader)(nil).ProtoMessage)) -} - -// Reset mocks base method. -func (m *MockHeader) Reset() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Reset") -} - -// Reset indicates an expected call of Reset. -func (mr *MockHeaderMockRecorder) Reset() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockHeader)(nil).Reset)) -} - -// String mocks base method. -func (m *MockHeader) String() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "String") - ret0, _ := ret[0].(string) - return ret0 -} - -// String indicates an expected call of String. -func (mr *MockHeaderMockRecorder) String() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockHeader)(nil).String)) -} - -// ValidateBasic mocks base method. -func (m *MockHeader) ValidateBasic() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidateBasic") - ret0, _ := ret[0].(error) - return ret0 -} - -// ValidateBasic indicates an expected call of ValidateBasic. -func (mr *MockHeaderMockRecorder) ValidateBasic() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateBasic", reflect.TypeOf((*MockHeader)(nil).ValidateBasic)) -} - -// MockSyncHeaders is a mock of SyncHeaders interface. -type MockSyncHeaders struct { - ctrl *gomock.Controller - recorder *MockSyncHeadersMockRecorder - isgomock struct{} -} - -// MockSyncHeadersMockRecorder is the mock recorder for MockSyncHeaders. -type MockSyncHeadersMockRecorder struct { - mock *MockSyncHeaders -} - -// NewMockSyncHeaders creates a new mock instance. -func NewMockSyncHeaders(ctrl *gomock.Controller) *MockSyncHeaders { - mock := &MockSyncHeaders{ctrl: ctrl} - mock.recorder = &MockSyncHeadersMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSyncHeaders) EXPECT() *MockSyncHeadersMockRecorder { - return m.recorder -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockSyncHeaders) GetLatestFinalizedHeader(chainID string) Header { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", chainID) - ret0, _ := ret[0].(Header) - return ret0 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockSyncHeadersMockRecorder) GetLatestFinalizedHeader(chainID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockSyncHeaders)(nil).GetLatestFinalizedHeader), chainID) -} - -// GetQueryContext mocks base method. -func (m *MockSyncHeaders) GetQueryContext(chainID string) QueryContext { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetQueryContext", chainID) - ret0, _ := ret[0].(QueryContext) - return ret0 -} - -// GetQueryContext indicates an expected call of GetQueryContext. -func (mr *MockSyncHeadersMockRecorder) GetQueryContext(chainID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryContext", reflect.TypeOf((*MockSyncHeaders)(nil).GetQueryContext), chainID) -} - -// SetupBothHeadersForUpdate mocks base method. -func (m *MockSyncHeaders) SetupBothHeadersForUpdate(src, dst ChainLightClient) ([]Header, []Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupBothHeadersForUpdate", src, dst) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].([]Header) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// SetupBothHeadersForUpdate indicates an expected call of SetupBothHeadersForUpdate. -func (mr *MockSyncHeadersMockRecorder) SetupBothHeadersForUpdate(src, dst any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupBothHeadersForUpdate", reflect.TypeOf((*MockSyncHeaders)(nil).SetupBothHeadersForUpdate), src, dst) -} - -// SetupHeadersForUpdate mocks base method. -func (m *MockSyncHeaders) SetupHeadersForUpdate(src, dst ChainLightClient) ([]Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupHeadersForUpdate", src, dst) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. -func (mr *MockSyncHeadersMockRecorder) SetupHeadersForUpdate(src, dst any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockSyncHeaders)(nil).SetupHeadersForUpdate), src, dst) -} - -// Updates mocks base method. -func (m *MockSyncHeaders) Updates(src, dst ChainInfoLightClient) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Updates", src, dst) - ret0, _ := ret[0].(error) - return ret0 -} - -// Updates indicates an expected call of Updates. -func (mr *MockSyncHeadersMockRecorder) Updates(src, dst any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Updates", reflect.TypeOf((*MockSyncHeaders)(nil).Updates), src, dst) -} - -// MockChainInfoLightClient is a mock of ChainInfoLightClient interface. -type MockChainInfoLightClient struct { - ctrl *gomock.Controller - recorder *MockChainInfoLightClientMockRecorder - isgomock struct{} -} - -// MockChainInfoLightClientMockRecorder is the mock recorder for MockChainInfoLightClient. -type MockChainInfoLightClientMockRecorder struct { - mock *MockChainInfoLightClient -} - -// NewMockChainInfoLightClient creates a new mock instance. -func NewMockChainInfoLightClient(ctrl *gomock.Controller) *MockChainInfoLightClient { - mock := &MockChainInfoLightClient{ctrl: ctrl} - mock.recorder = &MockChainInfoLightClientMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockChainInfoLightClient) EXPECT() *MockChainInfoLightClientMockRecorder { - return m.recorder -} - -// AverageBlockTime mocks base method. -func (m *MockChainInfoLightClient) AverageBlockTime() time.Duration { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AverageBlockTime") - ret0, _ := ret[0].(time.Duration) - return ret0 -} - -// AverageBlockTime indicates an expected call of AverageBlockTime. -func (mr *MockChainInfoLightClientMockRecorder) AverageBlockTime() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainInfoLightClient)(nil).AverageBlockTime)) -} - -// ChainID mocks base method. -func (m *MockChainInfoLightClient) ChainID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ChainID") - ret0, _ := ret[0].(string) - return ret0 -} - -// ChainID indicates an expected call of ChainID. -func (mr *MockChainInfoLightClientMockRecorder) ChainID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainInfoLightClient)(nil).ChainID)) -} - -// CheckRefreshRequired mocks base method. -func (m *MockChainInfoLightClient) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. -func (mr *MockChainInfoLightClientMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockChainInfoLightClient)(nil).CheckRefreshRequired), ctx, counterparty) -} - -// CreateInitialLightClientState mocks base method. -func (m *MockChainInfoLightClient) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) - ret0, _ := ret[0].(exported.ClientState) - ret1, _ := ret[1].(exported.ConsensusState) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. -func (mr *MockChainInfoLightClientMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockChainInfoLightClient)(nil).CreateInitialLightClientState), ctx, height) -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockChainInfoLightClient) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockChainInfoLightClientMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockChainInfoLightClient)(nil).GetLatestFinalizedHeader), ctx) -} - -// LatestHeight mocks base method. -func (m *MockChainInfoLightClient) LatestHeight(ctx context.Context) (exported.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestHeight", ctx) - ret0, _ := ret[0].(exported.Height) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LatestHeight indicates an expected call of LatestHeight. -func (mr *MockChainInfoLightClientMockRecorder) LatestHeight(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainInfoLightClient)(nil).LatestHeight), ctx) -} - -// SetupHeadersForUpdate mocks base method. -func (m *MockChainInfoLightClient) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. -func (mr *MockChainInfoLightClientMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockChainInfoLightClient)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) -} - -// Timestamp mocks base method. -func (m *MockChainInfoLightClient) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Timestamp", ctx, height) - ret0, _ := ret[0].(time.Time) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Timestamp indicates an expected call of Timestamp. -func (mr *MockChainInfoLightClientMockRecorder) Timestamp(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainInfoLightClient)(nil).Timestamp), ctx, height) -} - -// MockChainLightClient is a mock of ChainLightClient interface. -type MockChainLightClient struct { - ctrl *gomock.Controller - recorder *MockChainLightClientMockRecorder - isgomock struct{} -} - -// MockChainLightClientMockRecorder is the mock recorder for MockChainLightClient. -type MockChainLightClientMockRecorder struct { - mock *MockChainLightClient -} - -// NewMockChainLightClient creates a new mock instance. -func NewMockChainLightClient(ctrl *gomock.Controller) *MockChainLightClient { - mock := &MockChainLightClient{ctrl: ctrl} - mock.recorder = &MockChainLightClientMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockChainLightClient) EXPECT() *MockChainLightClientMockRecorder { - return m.recorder -} - -// AverageBlockTime mocks base method. -func (m *MockChainLightClient) AverageBlockTime() time.Duration { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AverageBlockTime") - ret0, _ := ret[0].(time.Duration) - return ret0 -} - -// AverageBlockTime indicates an expected call of AverageBlockTime. -func (mr *MockChainLightClientMockRecorder) AverageBlockTime() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainLightClient)(nil).AverageBlockTime)) -} - -// ChainID mocks base method. -func (m *MockChainLightClient) ChainID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ChainID") - ret0, _ := ret[0].(string) - return ret0 -} - -// ChainID indicates an expected call of ChainID. -func (mr *MockChainLightClientMockRecorder) ChainID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainLightClient)(nil).ChainID)) -} - -// CheckRefreshRequired mocks base method. -func (m *MockChainLightClient) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. -func (mr *MockChainLightClientMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockChainLightClient)(nil).CheckRefreshRequired), ctx, counterparty) -} - -// Codec mocks base method. -func (m *MockChainLightClient) Codec() codec.ProtoCodecMarshaler { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Codec") - ret0, _ := ret[0].(codec.ProtoCodecMarshaler) - return ret0 -} - -// Codec indicates an expected call of Codec. -func (mr *MockChainLightClientMockRecorder) Codec() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Codec", reflect.TypeOf((*MockChainLightClient)(nil).Codec)) -} - -// CreateInitialLightClientState mocks base method. -func (m *MockChainLightClient) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) - ret0, _ := ret[0].(exported.ClientState) - ret1, _ := ret[1].(exported.ConsensusState) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. -func (mr *MockChainLightClientMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockChainLightClient)(nil).CreateInitialLightClientState), ctx, height) -} - -// GetAddress mocks base method. -func (m *MockChainLightClient) GetAddress() (types.AccAddress, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAddress") - ret0, _ := ret[0].(types.AccAddress) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAddress indicates an expected call of GetAddress. -func (mr *MockChainLightClientMockRecorder) GetAddress() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockChainLightClient)(nil).GetAddress)) -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockChainLightClient) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockChainLightClientMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockChainLightClient)(nil).GetLatestFinalizedHeader), ctx) -} - -// GetMsgResult mocks base method. -func (m *MockChainLightClient) GetMsgResult(ctx context.Context, id MsgID) (MsgResult, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMsgResult", ctx, id) - ret0, _ := ret[0].(MsgResult) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMsgResult indicates an expected call of GetMsgResult. -func (mr *MockChainLightClientMockRecorder) GetMsgResult(ctx, id any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMsgResult", reflect.TypeOf((*MockChainLightClient)(nil).GetMsgResult), ctx, id) -} - -// Init mocks base method. -func (m *MockChainLightClient) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) - ret0, _ := ret[0].(error) - return ret0 -} - -// Init indicates an expected call of Init. -func (mr *MockChainLightClientMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockChainLightClient)(nil).Init), homePath, timeout, codec, debug) -} - -// LatestHeight mocks base method. -func (m *MockChainLightClient) LatestHeight(ctx context.Context) (exported.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestHeight", ctx) - ret0, _ := ret[0].(exported.Height) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LatestHeight indicates an expected call of LatestHeight. -func (mr *MockChainLightClientMockRecorder) LatestHeight(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainLightClient)(nil).LatestHeight), ctx) -} - -// Path mocks base method. -func (m *MockChainLightClient) Path() *PathEnd { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Path") - ret0, _ := ret[0].(*PathEnd) - return ret0 -} - -// Path indicates an expected call of Path. -func (mr *MockChainLightClientMockRecorder) Path() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockChainLightClient)(nil).Path)) -} - -// QueryBalance mocks base method. -func (m *MockChainLightClient) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryBalance", ctx, address) - ret0, _ := ret[0].(types.Coins) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryBalance indicates an expected call of QueryBalance. -func (mr *MockChainLightClientMockRecorder) QueryBalance(ctx, address any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockChainLightClient)(nil).QueryBalance), ctx, address) -} - -// QueryCanTransitionToFlushComplete mocks base method. -func (m *MockChainLightClient) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. -func (mr *MockChainLightClientMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockChainLightClient)(nil).QueryCanTransitionToFlushComplete), ctx) -} - -// QueryChannel mocks base method. -func (m *MockChainLightClient) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannel", ctx) - ret0, _ := ret[0].(*types3.QueryChannelResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannel indicates an expected call of QueryChannel. -func (mr *MockChainLightClientMockRecorder) QueryChannel(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockChainLightClient)(nil).QueryChannel), ctx) -} - -// QueryChannelUpgrade mocks base method. -func (m *MockChainLightClient) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. -func (mr *MockChainLightClientMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockChainLightClient)(nil).QueryChannelUpgrade), ctx) -} - -// QueryChannelUpgradeError mocks base method. -func (m *MockChainLightClient) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. -func (mr *MockChainLightClientMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockChainLightClient)(nil).QueryChannelUpgradeError), ctx) -} - -// QueryClientConsensusState mocks base method. -func (m *MockChainLightClient) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) - ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. -func (mr *MockChainLightClientMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockChainLightClient)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) -} - -// QueryClientState mocks base method. -func (m *MockChainLightClient) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientState", ctx) - ret0, _ := ret[0].(*types1.QueryClientStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientState indicates an expected call of QueryClientState. -func (mr *MockChainLightClientMockRecorder) QueryClientState(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockChainLightClient)(nil).QueryClientState), ctx) -} - -// QueryConnection mocks base method. -func (m *MockChainLightClient) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) - ret0, _ := ret[0].(*types2.QueryConnectionResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryConnection indicates an expected call of QueryConnection. -func (mr *MockChainLightClientMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockChainLightClient)(nil).QueryConnection), ctx, connectionID) -} - -// QueryDenomTraces mocks base method. -func (m *MockChainLightClient) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) - ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryDenomTraces indicates an expected call of QueryDenomTraces. -func (mr *MockChainLightClientMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockChainLightClient)(nil).QueryDenomTraces), ctx, offset, limit) -} - -// QueryNextSequenceReceive mocks base method. -func (m *MockChainLightClient) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockChainLightClientMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockChainLightClient)(nil).QueryNextSequenceReceive), ctx) -} - -// QueryUnfinalizedRelayAcknowledgements mocks base method. -func (m *MockChainLightClient) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. -func (mr *MockChainLightClientMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) -} - -// QueryUnfinalizedRelayPackets mocks base method. -func (m *MockChainLightClient) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. -func (mr *MockChainLightClientMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) -} - -// QueryUnreceivedAcknowledgements mocks base method. -func (m *MockChainLightClient) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. -func (mr *MockChainLightClientMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) -} - -// QueryUnreceivedPackets mocks base method. -func (m *MockChainLightClient) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. -func (mr *MockChainLightClientMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockChainLightClient)(nil).QueryUnreceivedPackets), ctx, seqs) -} - -// RegisterMsgEventListener mocks base method. -func (m *MockChainLightClient) RegisterMsgEventListener(arg0 MsgEventListener) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterMsgEventListener", arg0) -} - -// RegisterMsgEventListener indicates an expected call of RegisterMsgEventListener. -func (mr *MockChainLightClientMockRecorder) RegisterMsgEventListener(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMsgEventListener", reflect.TypeOf((*MockChainLightClient)(nil).RegisterMsgEventListener), arg0) -} - -// SendMsgs mocks base method. -func (m *MockChainLightClient) SendMsgs(ctx context.Context, msgs []types.Msg) ([]MsgID, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendMsgs", ctx, msgs) - ret0, _ := ret[0].([]MsgID) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendMsgs indicates an expected call of SendMsgs. -func (mr *MockChainLightClientMockRecorder) SendMsgs(ctx, msgs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsgs", reflect.TypeOf((*MockChainLightClient)(nil).SendMsgs), ctx, msgs) -} - -// SetRelayInfo mocks base method. -func (m *MockChainLightClient) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetRelayInfo indicates an expected call of SetRelayInfo. -func (mr *MockChainLightClientMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockChainLightClient)(nil).SetRelayInfo), path, counterparty, counterpartyPath) -} - -// SetupForRelay mocks base method. -func (m *MockChainLightClient) SetupForRelay(ctx context.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupForRelay", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetupForRelay indicates an expected call of SetupForRelay. -func (mr *MockChainLightClientMockRecorder) SetupForRelay(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockChainLightClient)(nil).SetupForRelay), ctx) -} - -// SetupHeadersForUpdate mocks base method. -func (m *MockChainLightClient) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. -func (mr *MockChainLightClientMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockChainLightClient)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) -} - -// Timestamp mocks base method. -func (m *MockChainLightClient) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Timestamp", ctx, height) - ret0, _ := ret[0].(time.Time) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Timestamp indicates an expected call of Timestamp. -func (mr *MockChainLightClientMockRecorder) Timestamp(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainLightClient)(nil).Timestamp), ctx, height) -} diff --git a/core/provers.go b/core/provers.go index db8cec38..e2762191 100644 --- a/core/provers.go +++ b/core/provers.go @@ -6,7 +6,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" - "github.com/cosmos/ibc-go/v8/modules/core/exported" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" ) // Prover represents a prover that supports generating a commitment proof @@ -31,7 +31,7 @@ type StateProver interface { // ProveHostConsensusState returns an existence proof of the consensus state at `height` // This proof would be ignored in ibc-go, but it is required to `getSelfConsensusState` of ibc-solidity. - ProveHostConsensusState(ctx QueryContext, height exported.Height, consensusState exported.ConsensusState) (proof []byte, err error) + ProveHostConsensusState(ctx QueryContext, height ibcexported.Height, consensusState ibcexported.ConsensusState) (proof []byte, err error) } // LightClient provides functions for creating and updating on-chain light clients on the counterparty chain @@ -41,7 +41,7 @@ type LightClient interface { // CreateInitialLightClientState returns a pair of ClientState and ConsensusState based on the state of the self chain at `height`. // These states will be submitted to the counterparty chain as MsgCreateClient. // If `height` is nil, the latest finalized height is selected automatically. - CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) + CreateInitialLightClientState(ctx context.Context, height ibcexported.Height) (ibcexported.ClientState, ibcexported.ConsensusState, error) // SetupHeadersForUpdate returns the finalized header and any intermediate headers needed to apply it to the client on the counterpaty chain // The order of the returned header slice should be as: [..., ] diff --git a/core/provers_testmock.go b/core/provers_testmock.go deleted file mode 100644 index 218d2a85..00000000 --- a/core/provers_testmock.go +++ /dev/null @@ -1,908 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: core/provers.go -// -// Generated by this command: -// -// mockgen -source core/provers.go -destination core/provers_testmock.go -package core -// - -// Package core is a generated GoMock package. -package core - -import ( - context "context" - reflect "reflect" - time "time" - - codec "github.com/cosmos/cosmos-sdk/codec" - types "github.com/cosmos/cosmos-sdk/types" - types0 "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" - types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" - types2 "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" - types3 "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" - exported "github.com/cosmos/ibc-go/v8/modules/core/exported" - gomock "go.uber.org/mock/gomock" -) - -// MockProver is a mock of Prover interface. -type MockProver struct { - ctrl *gomock.Controller - recorder *MockProverMockRecorder - isgomock struct{} -} - -// MockProverMockRecorder is the mock recorder for MockProver. -type MockProverMockRecorder struct { - mock *MockProver -} - -// NewMockProver creates a new mock instance. -func NewMockProver(ctrl *gomock.Controller) *MockProver { - mock := &MockProver{ctrl: ctrl} - mock.recorder = &MockProverMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProver) EXPECT() *MockProverMockRecorder { - return m.recorder -} - -// CheckRefreshRequired mocks base method. -func (m *MockProver) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. -func (mr *MockProverMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockProver)(nil).CheckRefreshRequired), ctx, counterparty) -} - -// CreateInitialLightClientState mocks base method. -func (m *MockProver) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) - ret0, _ := ret[0].(exported.ClientState) - ret1, _ := ret[1].(exported.ConsensusState) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. -func (mr *MockProverMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockProver)(nil).CreateInitialLightClientState), ctx, height) -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockProver) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockProverMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockProver)(nil).GetLatestFinalizedHeader), ctx) -} - -// Init mocks base method. -func (m *MockProver) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) - ret0, _ := ret[0].(error) - return ret0 -} - -// Init indicates an expected call of Init. -func (mr *MockProverMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockProver)(nil).Init), homePath, timeout, codec, debug) -} - -// ProveHostConsensusState mocks base method. -func (m *MockProver) ProveHostConsensusState(ctx QueryContext, height exported.Height, consensusState exported.ConsensusState) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProveHostConsensusState", ctx, height, consensusState) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProveHostConsensusState indicates an expected call of ProveHostConsensusState. -func (mr *MockProverMockRecorder) ProveHostConsensusState(ctx, height, consensusState any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveHostConsensusState", reflect.TypeOf((*MockProver)(nil).ProveHostConsensusState), ctx, height, consensusState) -} - -// ProveState mocks base method. -func (m *MockProver) ProveState(ctx QueryContext, path string, value []byte) ([]byte, types1.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProveState", ctx, path, value) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(types1.Height) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// ProveState indicates an expected call of ProveState. -func (mr *MockProverMockRecorder) ProveState(ctx, path, value any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveState", reflect.TypeOf((*MockProver)(nil).ProveState), ctx, path, value) -} - -// SetRelayInfo mocks base method. -func (m *MockProver) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetRelayInfo indicates an expected call of SetRelayInfo. -func (mr *MockProverMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockProver)(nil).SetRelayInfo), path, counterparty, counterpartyPath) -} - -// SetupForRelay mocks base method. -func (m *MockProver) SetupForRelay(ctx context.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupForRelay", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetupForRelay indicates an expected call of SetupForRelay. -func (mr *MockProverMockRecorder) SetupForRelay(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockProver)(nil).SetupForRelay), ctx) -} - -// SetupHeadersForUpdate mocks base method. -func (m *MockProver) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. -func (mr *MockProverMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockProver)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) -} - -// MockStateProver is a mock of StateProver interface. -type MockStateProver struct { - ctrl *gomock.Controller - recorder *MockStateProverMockRecorder - isgomock struct{} -} - -// MockStateProverMockRecorder is the mock recorder for MockStateProver. -type MockStateProverMockRecorder struct { - mock *MockStateProver -} - -// NewMockStateProver creates a new mock instance. -func NewMockStateProver(ctrl *gomock.Controller) *MockStateProver { - mock := &MockStateProver{ctrl: ctrl} - mock.recorder = &MockStateProverMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockStateProver) EXPECT() *MockStateProverMockRecorder { - return m.recorder -} - -// ProveHostConsensusState mocks base method. -func (m *MockStateProver) ProveHostConsensusState(ctx QueryContext, height exported.Height, consensusState exported.ConsensusState) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProveHostConsensusState", ctx, height, consensusState) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProveHostConsensusState indicates an expected call of ProveHostConsensusState. -func (mr *MockStateProverMockRecorder) ProveHostConsensusState(ctx, height, consensusState any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveHostConsensusState", reflect.TypeOf((*MockStateProver)(nil).ProveHostConsensusState), ctx, height, consensusState) -} - -// ProveState mocks base method. -func (m *MockStateProver) ProveState(ctx QueryContext, path string, value []byte) ([]byte, types1.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProveState", ctx, path, value) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(types1.Height) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// ProveState indicates an expected call of ProveState. -func (mr *MockStateProverMockRecorder) ProveState(ctx, path, value any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProveState", reflect.TypeOf((*MockStateProver)(nil).ProveState), ctx, path, value) -} - -// MockLightClient is a mock of LightClient interface. -type MockLightClient struct { - ctrl *gomock.Controller - recorder *MockLightClientMockRecorder - isgomock struct{} -} - -// MockLightClientMockRecorder is the mock recorder for MockLightClient. -type MockLightClientMockRecorder struct { - mock *MockLightClient -} - -// NewMockLightClient creates a new mock instance. -func NewMockLightClient(ctrl *gomock.Controller) *MockLightClient { - mock := &MockLightClient{ctrl: ctrl} - mock.recorder = &MockLightClientMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockLightClient) EXPECT() *MockLightClientMockRecorder { - return m.recorder -} - -// CheckRefreshRequired mocks base method. -func (m *MockLightClient) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. -func (mr *MockLightClientMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockLightClient)(nil).CheckRefreshRequired), ctx, counterparty) -} - -// CreateInitialLightClientState mocks base method. -func (m *MockLightClient) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) - ret0, _ := ret[0].(exported.ClientState) - ret1, _ := ret[1].(exported.ConsensusState) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. -func (mr *MockLightClientMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockLightClient)(nil).CreateInitialLightClientState), ctx, height) -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockLightClient) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockLightClientMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockLightClient)(nil).GetLatestFinalizedHeader), ctx) -} - -// SetupHeadersForUpdate mocks base method. -func (m *MockLightClient) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. -func (mr *MockLightClientMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockLightClient)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) -} - -// MockFinalityAware is a mock of FinalityAware interface. -type MockFinalityAware struct { - ctrl *gomock.Controller - recorder *MockFinalityAwareMockRecorder - isgomock struct{} -} - -// MockFinalityAwareMockRecorder is the mock recorder for MockFinalityAware. -type MockFinalityAwareMockRecorder struct { - mock *MockFinalityAware -} - -// NewMockFinalityAware creates a new mock instance. -func NewMockFinalityAware(ctrl *gomock.Controller) *MockFinalityAware { - mock := &MockFinalityAware{ctrl: ctrl} - mock.recorder = &MockFinalityAwareMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockFinalityAware) EXPECT() *MockFinalityAwareMockRecorder { - return m.recorder -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockFinalityAware) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockFinalityAwareMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockFinalityAware)(nil).GetLatestFinalizedHeader), ctx) -} - -// MockFinalityAwareChain is a mock of FinalityAwareChain interface. -type MockFinalityAwareChain struct { - ctrl *gomock.Controller - recorder *MockFinalityAwareChainMockRecorder - isgomock struct{} -} - -// MockFinalityAwareChainMockRecorder is the mock recorder for MockFinalityAwareChain. -type MockFinalityAwareChainMockRecorder struct { - mock *MockFinalityAwareChain -} - -// NewMockFinalityAwareChain creates a new mock instance. -func NewMockFinalityAwareChain(ctrl *gomock.Controller) *MockFinalityAwareChain { - mock := &MockFinalityAwareChain{ctrl: ctrl} - mock.recorder = &MockFinalityAwareChainMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockFinalityAwareChain) EXPECT() *MockFinalityAwareChainMockRecorder { - return m.recorder -} - -// AverageBlockTime mocks base method. -func (m *MockFinalityAwareChain) AverageBlockTime() time.Duration { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AverageBlockTime") - ret0, _ := ret[0].(time.Duration) - return ret0 -} - -// AverageBlockTime indicates an expected call of AverageBlockTime. -func (mr *MockFinalityAwareChainMockRecorder) AverageBlockTime() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockFinalityAwareChain)(nil).AverageBlockTime)) -} - -// ChainID mocks base method. -func (m *MockFinalityAwareChain) ChainID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ChainID") - ret0, _ := ret[0].(string) - return ret0 -} - -// ChainID indicates an expected call of ChainID. -func (mr *MockFinalityAwareChainMockRecorder) ChainID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockFinalityAwareChain)(nil).ChainID)) -} - -// Codec mocks base method. -func (m *MockFinalityAwareChain) Codec() codec.ProtoCodecMarshaler { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Codec") - ret0, _ := ret[0].(codec.ProtoCodecMarshaler) - return ret0 -} - -// Codec indicates an expected call of Codec. -func (mr *MockFinalityAwareChainMockRecorder) Codec() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Codec", reflect.TypeOf((*MockFinalityAwareChain)(nil).Codec)) -} - -// GetAddress mocks base method. -func (m *MockFinalityAwareChain) GetAddress() (types.AccAddress, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAddress") - ret0, _ := ret[0].(types.AccAddress) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAddress indicates an expected call of GetAddress. -func (mr *MockFinalityAwareChainMockRecorder) GetAddress() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockFinalityAwareChain)(nil).GetAddress)) -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockFinalityAwareChain) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockFinalityAwareChainMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockFinalityAwareChain)(nil).GetLatestFinalizedHeader), ctx) -} - -// GetMsgResult mocks base method. -func (m *MockFinalityAwareChain) GetMsgResult(ctx context.Context, id MsgID) (MsgResult, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMsgResult", ctx, id) - ret0, _ := ret[0].(MsgResult) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMsgResult indicates an expected call of GetMsgResult. -func (mr *MockFinalityAwareChainMockRecorder) GetMsgResult(ctx, id any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMsgResult", reflect.TypeOf((*MockFinalityAwareChain)(nil).GetMsgResult), ctx, id) -} - -// Init mocks base method. -func (m *MockFinalityAwareChain) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) - ret0, _ := ret[0].(error) - return ret0 -} - -// Init indicates an expected call of Init. -func (mr *MockFinalityAwareChainMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockFinalityAwareChain)(nil).Init), homePath, timeout, codec, debug) -} - -// LatestHeight mocks base method. -func (m *MockFinalityAwareChain) LatestHeight(ctx context.Context) (exported.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestHeight", ctx) - ret0, _ := ret[0].(exported.Height) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LatestHeight indicates an expected call of LatestHeight. -func (mr *MockFinalityAwareChainMockRecorder) LatestHeight(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockFinalityAwareChain)(nil).LatestHeight), ctx) -} - -// Path mocks base method. -func (m *MockFinalityAwareChain) Path() *PathEnd { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Path") - ret0, _ := ret[0].(*PathEnd) - return ret0 -} - -// Path indicates an expected call of Path. -func (mr *MockFinalityAwareChainMockRecorder) Path() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockFinalityAwareChain)(nil).Path)) -} - -// QueryBalance mocks base method. -func (m *MockFinalityAwareChain) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryBalance", ctx, address) - ret0, _ := ret[0].(types.Coins) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryBalance indicates an expected call of QueryBalance. -func (mr *MockFinalityAwareChainMockRecorder) QueryBalance(ctx, address any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryBalance), ctx, address) -} - -// QueryCanTransitionToFlushComplete mocks base method. -func (m *MockFinalityAwareChain) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. -func (mr *MockFinalityAwareChainMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryCanTransitionToFlushComplete), ctx) -} - -// QueryChannel mocks base method. -func (m *MockFinalityAwareChain) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannel", ctx) - ret0, _ := ret[0].(*types3.QueryChannelResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannel indicates an expected call of QueryChannel. -func (mr *MockFinalityAwareChainMockRecorder) QueryChannel(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryChannel), ctx) -} - -// QueryChannelUpgrade mocks base method. -func (m *MockFinalityAwareChain) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. -func (mr *MockFinalityAwareChainMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryChannelUpgrade), ctx) -} - -// QueryChannelUpgradeError mocks base method. -func (m *MockFinalityAwareChain) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. -func (mr *MockFinalityAwareChainMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryChannelUpgradeError), ctx) -} - -// QueryClientConsensusState mocks base method. -func (m *MockFinalityAwareChain) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) - ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. -func (mr *MockFinalityAwareChainMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) -} - -// QueryClientState mocks base method. -func (m *MockFinalityAwareChain) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientState", ctx) - ret0, _ := ret[0].(*types1.QueryClientStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientState indicates an expected call of QueryClientState. -func (mr *MockFinalityAwareChainMockRecorder) QueryClientState(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryClientState), ctx) -} - -// QueryConnection mocks base method. -func (m *MockFinalityAwareChain) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) - ret0, _ := ret[0].(*types2.QueryConnectionResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryConnection indicates an expected call of QueryConnection. -func (mr *MockFinalityAwareChainMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryConnection), ctx, connectionID) -} - -// QueryDenomTraces mocks base method. -func (m *MockFinalityAwareChain) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) - ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryDenomTraces indicates an expected call of QueryDenomTraces. -func (mr *MockFinalityAwareChainMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryDenomTraces), ctx, offset, limit) -} - -// QueryNextSequenceReceive mocks base method. -func (m *MockFinalityAwareChain) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockFinalityAwareChainMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryNextSequenceReceive), ctx) -} - -// QueryUnfinalizedRelayAcknowledgements mocks base method. -func (m *MockFinalityAwareChain) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. -func (mr *MockFinalityAwareChainMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) -} - -// QueryUnfinalizedRelayPackets mocks base method. -func (m *MockFinalityAwareChain) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. -func (mr *MockFinalityAwareChainMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) -} - -// QueryUnreceivedAcknowledgements mocks base method. -func (m *MockFinalityAwareChain) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. -func (mr *MockFinalityAwareChainMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) -} - -// QueryUnreceivedPackets mocks base method. -func (m *MockFinalityAwareChain) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. -func (mr *MockFinalityAwareChainMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockFinalityAwareChain)(nil).QueryUnreceivedPackets), ctx, seqs) -} - -// RegisterMsgEventListener mocks base method. -func (m *MockFinalityAwareChain) RegisterMsgEventListener(arg0 MsgEventListener) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterMsgEventListener", arg0) -} - -// RegisterMsgEventListener indicates an expected call of RegisterMsgEventListener. -func (mr *MockFinalityAwareChainMockRecorder) RegisterMsgEventListener(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMsgEventListener", reflect.TypeOf((*MockFinalityAwareChain)(nil).RegisterMsgEventListener), arg0) -} - -// SendMsgs mocks base method. -func (m *MockFinalityAwareChain) SendMsgs(ctx context.Context, msgs []types.Msg) ([]MsgID, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendMsgs", ctx, msgs) - ret0, _ := ret[0].([]MsgID) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendMsgs indicates an expected call of SendMsgs. -func (mr *MockFinalityAwareChainMockRecorder) SendMsgs(ctx, msgs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsgs", reflect.TypeOf((*MockFinalityAwareChain)(nil).SendMsgs), ctx, msgs) -} - -// SetRelayInfo mocks base method. -func (m *MockFinalityAwareChain) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetRelayInfo indicates an expected call of SetRelayInfo. -func (mr *MockFinalityAwareChainMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockFinalityAwareChain)(nil).SetRelayInfo), path, counterparty, counterpartyPath) -} - -// SetupForRelay mocks base method. -func (m *MockFinalityAwareChain) SetupForRelay(ctx context.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupForRelay", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetupForRelay indicates an expected call of SetupForRelay. -func (mr *MockFinalityAwareChainMockRecorder) SetupForRelay(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockFinalityAwareChain)(nil).SetupForRelay), ctx) -} - -// Timestamp mocks base method. -func (m *MockFinalityAwareChain) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Timestamp", ctx, height) - ret0, _ := ret[0].(time.Time) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Timestamp indicates an expected call of Timestamp. -func (mr *MockFinalityAwareChainMockRecorder) Timestamp(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockFinalityAwareChain)(nil).Timestamp), ctx, height) -} - -// MockChainInfoICS02Querier is a mock of ChainInfoICS02Querier interface. -type MockChainInfoICS02Querier struct { - ctrl *gomock.Controller - recorder *MockChainInfoICS02QuerierMockRecorder - isgomock struct{} -} - -// MockChainInfoICS02QuerierMockRecorder is the mock recorder for MockChainInfoICS02Querier. -type MockChainInfoICS02QuerierMockRecorder struct { - mock *MockChainInfoICS02Querier -} - -// NewMockChainInfoICS02Querier creates a new mock instance. -func NewMockChainInfoICS02Querier(ctrl *gomock.Controller) *MockChainInfoICS02Querier { - mock := &MockChainInfoICS02Querier{ctrl: ctrl} - mock.recorder = &MockChainInfoICS02QuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockChainInfoICS02Querier) EXPECT() *MockChainInfoICS02QuerierMockRecorder { - return m.recorder -} - -// AverageBlockTime mocks base method. -func (m *MockChainInfoICS02Querier) AverageBlockTime() time.Duration { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AverageBlockTime") - ret0, _ := ret[0].(time.Duration) - return ret0 -} - -// AverageBlockTime indicates an expected call of AverageBlockTime. -func (mr *MockChainInfoICS02QuerierMockRecorder) AverageBlockTime() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).AverageBlockTime)) -} - -// ChainID mocks base method. -func (m *MockChainInfoICS02Querier) ChainID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ChainID") - ret0, _ := ret[0].(string) - return ret0 -} - -// ChainID indicates an expected call of ChainID. -func (mr *MockChainInfoICS02QuerierMockRecorder) ChainID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).ChainID)) -} - -// LatestHeight mocks base method. -func (m *MockChainInfoICS02Querier) LatestHeight(ctx context.Context) (exported.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestHeight", ctx) - ret0, _ := ret[0].(exported.Height) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LatestHeight indicates an expected call of LatestHeight. -func (mr *MockChainInfoICS02QuerierMockRecorder) LatestHeight(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).LatestHeight), ctx) -} - -// QueryClientConsensusState mocks base method. -func (m *MockChainInfoICS02Querier) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) - ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. -func (mr *MockChainInfoICS02QuerierMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) -} - -// QueryClientState mocks base method. -func (m *MockChainInfoICS02Querier) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientState", ctx) - ret0, _ := ret[0].(*types1.QueryClientStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientState indicates an expected call of QueryClientState. -func (mr *MockChainInfoICS02QuerierMockRecorder) QueryClientState(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).QueryClientState), ctx) -} - -// Timestamp mocks base method. -func (m *MockChainInfoICS02Querier) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Timestamp", ctx, height) - ret0, _ := ret[0].(time.Time) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Timestamp indicates an expected call of Timestamp. -func (mr *MockChainInfoICS02QuerierMockRecorder) Timestamp(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainInfoICS02Querier)(nil).Timestamp), ctx, height) -} diff --git a/core/service_test.go b/core/service_test.go index 19d3b93b..e4af38a1 100644 --- a/core/service_test.go +++ b/core/service_test.go @@ -1,4 +1,4 @@ -package core +package core_test import ( "testing" @@ -7,80 +7,225 @@ import ( "time" "context" "os" + "fmt" + "reflect" + + sdk "github.com/cosmos/cosmos-sdk/types" + clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" + chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" + mocktypes "github.com/datachainlab/ibc-mock-client/modules/light-clients/xx-mock/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" + + "github.com/hyperledger-labs/yui-relayer/core" "github.com/hyperledger-labs/yui-relayer/log" + "github.com/hyperledger-labs/yui-relayer/provers/mock" + "github.com/hyperledger-labs/yui-relayer/metrics" + "github.com/hyperledger-labs/yui-relayer/chains/tendermint" ) -func TestServe(t *testing.T) { - log.InitLoggerWithWriter("debug", "text", os.Stdout) +type NaiveStrategyWrap struct { + Inner *core.NaiveStrategy - ctrl := gomock.NewController(t) + UnrelayedPacketsOut *core.RelayPackets + UnrelayedAcknowledgementsOut *core.RelayPackets + RelayPacketsOut *core.RelayMsgs + RelayAcknowledgementsOut *core.RelayMsgs + UpdateClientsOut *core.RelayMsgs + SendIn *core.RelayMsgs +} +func (s *NaiveStrategyWrap) GetType() string { return s.Inner.GetType() } +func (s *NaiveStrategyWrap) SetupRelay(ctx context.Context, src, dst *core.ProvableChain) error { return s.Inner.SetupRelay(ctx, src, dst) } +func (s *NaiveStrategyWrap) UnrelayedPackets(src, dst *core.ProvableChain, sh core.SyncHeaders, includeRelayedButUnfinalized bool) (*core.RelayPackets, error) { + ret, err := s.Inner.UnrelayedPackets(src, dst, sh, includeRelayedButUnfinalized) + s.UnrelayedPacketsOut = ret + return ret, err +} +func (s *NaiveStrategyWrap) RelayPackets(src, dst *core.ProvableChain, rp *core.RelayPackets, sh core.SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*core.RelayMsgs, error) { + ret, err := s.Inner.RelayPackets(src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) + s.RelayPacketsOut = ret + return ret, err +} +func (s *NaiveStrategyWrap) UnrelayedAcknowledgements(src, dst *core.ProvableChain, sh core.SyncHeaders, includeRelayedButUnfinalized bool) (*core.RelayPackets, error) { + ret, err := s.Inner.UnrelayedAcknowledgements(src, dst, sh, includeRelayedButUnfinalized) + s.UnrelayedAcknowledgementsOut = ret + return ret, err +} +func (s *NaiveStrategyWrap) RelayAcknowledgements(src, dst *core.ProvableChain, rp *core.RelayPackets, sh core.SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*core.RelayMsgs, error) { + ret, err := s.Inner.RelayAcknowledgements(src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) + s.RelayAcknowledgementsOut = ret + return ret, err +} +func (s *NaiveStrategyWrap) UpdateClients(src, dst *core.ProvableChain, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst bool, sh core.SyncHeaders, doRefresh bool) (*core.RelayMsgs, error) { + ret, err := s.Inner.UpdateClients(src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) + fmt.Printf("UpdateClients: %v, %v, %v, %v, %v\n", doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, doRefresh) + s.UpdateClientsOut = ret + return ret, err +} +func (s *NaiveStrategyWrap) Send(src, dst core.Chain, msgs *core.RelayMsgs) { + s.SendIn = msgs + s.Inner.Send(src, dst, msgs) +} - st := NewMockStrategyI(ctrl) - sh := NewMockSyncHeaders(ctrl) - srcChain := NewMockChain(ctrl) - srcProver := NewMockProver(ctrl) - dstChain := NewMockChain(ctrl) - dstProver := NewMockProver(ctrl) - - src := NewProvableChain(srcChain, srcProver) - dst := NewProvableChain(dstChain, dstProver) - srv := NewRelayService(st, src, dst, sh, time.Minute, time.Minute, 3, time.Minute, 3) - - srcChain.EXPECT().ChainID().Return("srcChain").AnyTimes() - srcChain.EXPECT().Path().Return(&PathEnd{ - ChainID: "srcChain", - ClientID: "srcClient", - ConnectionID: "srcConn", - ChannelID: "srcChan", - PortID: "srcPort", - Order: "ORDERED", - Version: "srcVersion", +func NewMockProvableChain( + ctrl *gomock.Controller, + name, order string, + header mocktypes.Header, + unfinalizedRelayPackets core.PacketInfoList, + unreceivedPackets []uint64, +) *core.ProvableChain { + chain := core.NewMockChain(ctrl) + prover := mock.NewProver(chain, mock.ProverConfig{ FinalityDelay: 10 }) + + chain.EXPECT().ChainID().Return(name + "Chain").AnyTimes() + chain.EXPECT().Codec().Return(nil).AnyTimes() + chain.EXPECT().GetAddress().Return(sdk.AccAddress{}, nil).AnyTimes() + chain.EXPECT().Path().Return(&core.PathEnd{ + ChainID: name + "Chain", + ClientID: name + "Client", + ConnectionID: name + "Conn", + ChannelID: name + "Chan", + PortID: name + "Port", + Order: order, + Version: name + "Version", }).AnyTimes() - - dstChain.EXPECT().ChainID().Return("dstChain").AnyTimes() - dstChain.EXPECT().Path().Return(&PathEnd{ - ChainID: "dstChain", - ClientID: "dstClient", - ConnectionID: "dstConn", - ChannelID: "dstChan", - PortID: "dstPort", - Order: "ORDERED", - Version: "dstVersion", + chain.EXPECT().LatestHeight(gomock.Any()).Return(header.Height, nil).AnyTimes() + chain.EXPECT().Timestamp(gomock.Any(), gomock.Any()).DoAndReturn( + func(ctx context.Context, h ibcexported.Height) (time.Time, error) { + return time.Unix(0, int64(10000 + h.GetRevisionHeight())), nil + }).AnyTimes() + chain.EXPECT().QueryUnfinalizedRelayPackets(gomock.Any(), gomock.Any()).Return(unfinalizedRelayPackets, nil) + chain.EXPECT().QueryUnreceivedPackets(gomock.Any(), gomock.Any()).Return(unreceivedPackets, nil).AnyTimes() + chain.EXPECT().QueryUnfinalizedRelayAcknowledgements(gomock.Any(), gomock.Any()).Return([]*core.PacketInfo{}, nil).AnyTimes() + chain.EXPECT().QueryUnreceivedAcknowledgements(gomock.Any(), gomock.Any()).Return([]uint64{}, nil).AnyTimes() + chain.EXPECT().SendMsgs(gomock.Any(), gomock.Any()).DoAndReturn(func(ctx context.Context, msgs []sdk.Msg) ([]core.MsgID, error) { + var msgIDs []core.MsgID + for _, _ = range msgs { + msgIDs = append(msgIDs, &tendermint.MsgID{TxHash:"", MsgIndex:0}) + } + return msgIDs, nil }).AnyTimes() + return core.NewProvableChain(chain, prover) +} + +type testCase struct { + Order string + dstOptimizeCount uint64 + UnfinalizedRelayPackets core.PacketInfoList + ExpectSend []string +} - sh.EXPECT().Updates(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() +func newPacketInfo(seq uint64, timeoutHeight uint64) (*core.PacketInfo) { + return &core.PacketInfo{ + Packet: chantypes.NewPacket( + []byte{}, + seq, + "srcPort", + "srcChannel", + "dstPort", + "dstChannel", + clienttypes.NewHeight(1, timeoutHeight), + ^uint64(0), + ), + EventHeight: clienttypes.NewHeight(1, 1), + } +} - st.EXPECT().UnrelayedPackets(gomock.Any(), gomock.Any(), gomock.Any(), false).Return( - &RelayPackets{ - Src: []*PacketInfo{ +func TestServe(t *testing.T) { + cases := map[string]testCase{ + "empty": { + "ORDERED", + 1, + []*core.PacketInfo{}, + []string{ }, - Dst: []*PacketInfo{ + }, + "single": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 99999), }, - }, nil, - ) - - st.EXPECT().UnrelayedAcknowledgements(gomock.Any(), gomock.Any(), gomock.Any(), false).Return( - &RelayPackets{ - Src: []*PacketInfo{ + []string{ + "MsgUpdateClient(dstClient)", + "MsgRecvPacket(1)", + }, + }, + "queued": { + "ORDERED", + 9, + []*core.PacketInfo{ + newPacketInfo(1, 99999), }, - Dst: []*PacketInfo{ + []string{ }, - }, nil, - ) + }, + } + for n, c := range cases { + if n[0] == '_' { continue } + t.Run(n, func (t2 *testing.T) { testServe(t2, c) }) + } +} - st.EXPECT().UpdateClients(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), true).Return( - NewRelayMsgs(), nil, - ) +func testServe(t *testing.T, tc testCase) { + log.InitLoggerWithWriter("debug", "text", os.Stdout) + metrics.InitializeMetrics(metrics.ExporterNull{}) - st.EXPECT().RelayPackets(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return( - NewRelayMsgs(), nil, - ) + srcLatestHeader := mocktypes.Header{ + Height: clienttypes.NewHeight(10, 99), + Timestamp: uint64(10099), + } + dstLatestHeader := mocktypes.Header{ + Height: clienttypes.NewHeight(110, 199), + Timestamp: uint64(10199), + } - st.EXPECT().RelayAcknowledgements(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return( - NewRelayMsgs(), nil, - ) + ctrl := gomock.NewController(t) - st.EXPECT().Send(gomock.Any(), gomock.Any(), gomock.Any()) + var unreceivedPackets []uint64 + for _, p := range tc.UnfinalizedRelayPackets { + unreceivedPackets = append(unreceivedPackets, p.Sequence) + } + src := NewMockProvableChain(ctrl, "src", tc.Order, srcLatestHeader, tc.UnfinalizedRelayPackets, []uint64{}) + dst := NewMockProvableChain(ctrl, "dst", tc.Order, dstLatestHeader, []*core.PacketInfo{}, unreceivedPackets) + + st := &NaiveStrategyWrap{ Inner: core.NewNaiveStrategy(false, false) } + sh, err := core.NewSyncHeaders(src, dst) + if err != nil { + fmt.Printf("NewSyncHeders: %v\n", err) + } + var forever time.Duration = 1 << 63 - 1 + srv := core.NewRelayService(st, src, dst, sh, time.Minute, forever, 1, forever, tc.dstOptimizeCount) srv.Serve(context.TODO()) + fmt.Printf("UnrelayedPackets: %v\n", st.UnrelayedPacketsOut) + fmt.Printf("UnrelayedAcknowledgementsOut: %v\n", st.UnrelayedAcknowledgementsOut) + fmt.Printf("RelayPacketsOut: %v\n", st.RelayPacketsOut) + fmt.Printf("RelayAcknowledgementsOut: %v\n", st.RelayAcknowledgementsOut) + fmt.Printf("UpdateClientsOut: %v\n", st.UpdateClientsOut) + fmt.Printf("Send.Src: %v\n", st.SendIn.Src) + fmt.Printf("Send.Dst: %v\n", st.SendIn.Dst) + if len(st.SendIn.Dst) != len(tc.ExpectSend) { + t.Fatal(fmt.Sprintf("sendExpect size mismatch: %v but %v", len(tc.ExpectSend), len(st.SendIn.Dst))) + } + for i, msg := range st.SendIn.Dst { + //fmt.Printf(" %v: %v\n", i, proto.MessaageName(msg)) + typeof := reflect.TypeOf(msg).Elem().Name() + var desc string + switch typeof { + case "MsgUpdateClient": + m := msg.(*clienttypes.MsgUpdateClient) + desc = fmt.Sprintf("%s(%s)", typeof, m.ClientId) + case"MsgRecvPacket": + m := msg.(*chantypes.MsgRecvPacket) + desc = fmt.Sprintf("%s(%v)", typeof, m.Packet.GetSequence()) + case"MsgTimeout": + m := msg.(*chantypes.MsgTimeout) + desc = fmt.Sprintf("%s(%v)", typeof, m.Packet.GetSequence()) + default: + desc = fmt.Sprintf("%s()", typeof) + } + if desc != tc.ExpectSend[i] { + t.Fatal(fmt.Sprintf("send mismatch at %v: '%s' but '%s'", i, tc.ExpectSend[i], desc)) + } + } } diff --git a/core/strategies_testmock.go b/core/strategies_testmock.go deleted file mode 100644 index e01f8fcf..00000000 --- a/core/strategies_testmock.go +++ /dev/null @@ -1,156 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: core/strategies.go -// -// Generated by this command: -// -// mockgen -source core/strategies.go -destination core/strategies_testmock.go -package core -// - -// Package core is a generated GoMock package. -package core - -import ( - context "context" - reflect "reflect" - - gomock "go.uber.org/mock/gomock" -) - -// MockStrategyI is a mock of StrategyI interface. -type MockStrategyI struct { - ctrl *gomock.Controller - recorder *MockStrategyIMockRecorder - isgomock struct{} -} - -// MockStrategyIMockRecorder is the mock recorder for MockStrategyI. -type MockStrategyIMockRecorder struct { - mock *MockStrategyI -} - -// NewMockStrategyI creates a new mock instance. -func NewMockStrategyI(ctrl *gomock.Controller) *MockStrategyI { - mock := &MockStrategyI{ctrl: ctrl} - mock.recorder = &MockStrategyIMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockStrategyI) EXPECT() *MockStrategyIMockRecorder { - return m.recorder -} - -// GetType mocks base method. -func (m *MockStrategyI) GetType() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetType") - ret0, _ := ret[0].(string) - return ret0 -} - -// GetType indicates an expected call of GetType. -func (mr *MockStrategyIMockRecorder) GetType() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetType", reflect.TypeOf((*MockStrategyI)(nil).GetType)) -} - -// RelayAcknowledgements mocks base method. -func (m *MockStrategyI) RelayAcknowledgements(src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*RelayMsgs, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RelayAcknowledgements", src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) - ret0, _ := ret[0].(*RelayMsgs) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RelayAcknowledgements indicates an expected call of RelayAcknowledgements. -func (mr *MockStrategyIMockRecorder) RelayAcknowledgements(src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RelayAcknowledgements", reflect.TypeOf((*MockStrategyI)(nil).RelayAcknowledgements), src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) -} - -// RelayPackets mocks base method. -func (m *MockStrategyI) RelayPackets(src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*RelayMsgs, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RelayPackets", src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) - ret0, _ := ret[0].(*RelayMsgs) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RelayPackets indicates an expected call of RelayPackets. -func (mr *MockStrategyIMockRecorder) RelayPackets(src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RelayPackets", reflect.TypeOf((*MockStrategyI)(nil).RelayPackets), src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) -} - -// Send mocks base method. -func (m *MockStrategyI) Send(src, dst Chain, msgs *RelayMsgs) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Send", src, dst, msgs) -} - -// Send indicates an expected call of Send. -func (mr *MockStrategyIMockRecorder) Send(src, dst, msgs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockStrategyI)(nil).Send), src, dst, msgs) -} - -// SetupRelay mocks base method. -func (m *MockStrategyI) SetupRelay(ctx context.Context, src, dst *ProvableChain) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupRelay", ctx, src, dst) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetupRelay indicates an expected call of SetupRelay. -func (mr *MockStrategyIMockRecorder) SetupRelay(ctx, src, dst any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupRelay", reflect.TypeOf((*MockStrategyI)(nil).SetupRelay), ctx, src, dst) -} - -// UnrelayedAcknowledgements mocks base method. -func (m *MockStrategyI) UnrelayedAcknowledgements(src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnrelayedAcknowledgements", src, dst, sh, includeRelayedButUnfinalized) - ret0, _ := ret[0].(*RelayPackets) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnrelayedAcknowledgements indicates an expected call of UnrelayedAcknowledgements. -func (mr *MockStrategyIMockRecorder) UnrelayedAcknowledgements(src, dst, sh, includeRelayedButUnfinalized any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrelayedAcknowledgements", reflect.TypeOf((*MockStrategyI)(nil).UnrelayedAcknowledgements), src, dst, sh, includeRelayedButUnfinalized) -} - -// UnrelayedPackets mocks base method. -func (m *MockStrategyI) UnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnrelayedPackets", src, dst, sh, includeRelayedButUnfinalized) - ret0, _ := ret[0].(*RelayPackets) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnrelayedPackets indicates an expected call of UnrelayedPackets. -func (mr *MockStrategyIMockRecorder) UnrelayedPackets(src, dst, sh, includeRelayedButUnfinalized any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrelayedPackets", reflect.TypeOf((*MockStrategyI)(nil).UnrelayedPackets), src, dst, sh, includeRelayedButUnfinalized) -} - -// UpdateClients mocks base method. -func (m *MockStrategyI) UpdateClients(src, dst *ProvableChain, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst bool, sh SyncHeaders, doRefresh bool) (*RelayMsgs, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateClients", src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) - ret0, _ := ret[0].(*RelayMsgs) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateClients indicates an expected call of UpdateClients. -func (mr *MockStrategyIMockRecorder) UpdateClients(src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClients", reflect.TypeOf((*MockStrategyI)(nil).UpdateClients), src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) -} From 4d0c1e3c8c6c76aec940d94502b29af701369942 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Fri, 14 Mar 2025 06:55:06 +0000 Subject: [PATCH 03/14] restore wrongly removed lines Signed-off-by: Daisuke Kanda --- Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile b/Makefile index e361e6d1..e284f468 100644 --- a/Makefile +++ b/Makefile @@ -19,6 +19,7 @@ proto-gen: proto-update-deps: @echo "Updating Protobuf dependencies" + $(DOCKER) run --user 0 --rm -v $(CURDIR)/proto:/workspace --workdir /workspace $(protoImageName) buf mod update $(TESTMOCKS): go generate ./... From 6109a7a6b969b2ca4b8ff91358f65ec95aab1775 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 17 Mar 2025 03:26:14 +0000 Subject: [PATCH 04/14] impl timeout Signed-off-by: Daisuke Kanda --- chains/tendermint/query.go | 13 ++++++ core/chain.go | 3 ++ core/naive-strategy.go | 92 +++++++++++++++++++++++++++++++++++++- core/service.go | 10 ++++- core/strategies.go | 3 ++ core/types.go | 1 + 6 files changed, 119 insertions(+), 3 deletions(-) diff --git a/chains/tendermint/query.go b/chains/tendermint/query.go index 1cb68650..aefccac8 100644 --- a/chains/tendermint/query.go +++ b/chains/tendermint/query.go @@ -101,6 +101,19 @@ func (c *Chain) queryChannel(ctx context.Context, height int64, prove bool) (cha return res, nil } +// QueryNextSequenceReceive returns a info about nextSequence +func (c *Chain) QueryNextSequenceReceive(ctx core.QueryContext) (res *chantypes.QueryNextSequenceReceiveResponse, err error) { + return c.queryNextSequenceReceive(ctx.Context(), int64(ctx.Height().GetRevisionHeight()), false) +} + +func (c *Chain) queryNextSequenceReceive(ctx context.Context, height int64, prove bool) (chanRes *chantypes.QueryNextSequenceReceiveResponse, err error) { + res, err := chanutils.QueryNextSequenceReceive(c.CLIContext(height).WithCmdContext(ctx), c.PathEnd.PortID, c.PathEnd.ChannelID, prove) + if err != nil { + return nil, err + } + return res, nil +} + // QueryClientConsensusState retrieves the latest consensus state for a client in state at a given height func (c *Chain) QueryClientConsensusState( ctx core.QueryContext, dstClientConsHeight ibcexported.Height) (*clienttypes.QueryConsensusStateResponse, error) { diff --git a/core/chain.go b/core/chain.go index fcbf0a91..239a9f9d 100644 --- a/core/chain.go +++ b/core/chain.go @@ -145,6 +145,9 @@ type ICS04Querier interface { // QueryChannel returns the channel associated with a channelID QueryChannel(ctx QueryContext) (chanRes *chantypes.QueryChannelResponse, err error) + // QueryNextSequenceReceive returns a info about nextSequence + QueryNextSequenceReceive(ctx QueryContext) (res *chantypes.QueryNextSequenceReceiveResponse, err error) + // QueryUnreceivedPackets returns a list of unrelayed packet commitments QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index 54cbd1c5..550270da 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -8,6 +8,7 @@ import ( retry "github.com/avast/retry-go" sdk "github.com/cosmos/cosmos-sdk/types" + ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported" chantypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" host "github.com/cosmos/ibc-go/v8/modules/core/24-host" "github.com/hyperledger-labs/yui-relayer/metrics" @@ -199,6 +200,74 @@ func (st *NaiveStrategy) UnrelayedPackets(ctx context.Context, src, dst *Provabl }, nil } +func (st *NaiveStrategy) SortUnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) { + logger := GetChannelPairLogger(src, dst) + var ( + srcPackets PacketInfoList + dstPackets PacketInfoList + srcHeight ibcexported.Height + srcTimestamp uint64 + dstHeight ibcexported.Height + dstTimestamp uint64 + ) + + if 0 < len(rp.Src) { + dstHeight := sh.GetLatestFinalizedHeader(dst.ChainID()).GetHeight() + timestamp, err := dst.Timestamp(context.TODO(), dstHeight) + if err != nil { + logger.Error("fail to get dst.Timestamp", err) + return nil, err + } + dstTimestamp = uint64(timestamp.UnixNano()) + } + if 0 < len(rp.Dst) { + srcHeight := sh.GetLatestFinalizedHeader(src.ChainID()).GetHeight() + timestamp, err := src.Timestamp(context.TODO(), srcHeight) + if err != nil { + logger.Error("fail to get src.Timestamp", err) + return nil, err + } + srcTimestamp = uint64(timestamp.UnixNano()) + } + + for i, p := range rp.Src { + if (!p.TimeoutHeight.IsZero() && p.TimeoutHeight.LTE(dstHeight)) || + (p.TimeoutTimestamp != 0 && p.TimeoutTimestamp <= dstTimestamp) { + p.Sort = "timeout" + if src.Path().GetOrder() == chantypes.ORDERED { + if i == 0 { + dstPackets = append(dstPackets, p) + } + break + } else { + dstPackets = append(dstPackets, p) + } + } else { + srcPackets = append(srcPackets, p) + } + } + for i, p := range rp.Dst { + if (!p.TimeoutHeight.IsZero() && p.TimeoutHeight.LTE(srcHeight)) || + (p.TimeoutTimestamp != 0 && p.TimeoutTimestamp <= srcTimestamp) { + p.Sort = "timeout" + if dst.Path().GetOrder() == chantypes.ORDERED { + if i == 0 { + srcPackets = append(srcPackets, p) + } + break + } else { + srcPackets = append(srcPackets, p) + } + } else { + dstPackets = append(dstPackets, p) + } + } + return &RelayPackets{ + Src: srcPackets, + Dst: dstPackets, + }, nil +} + func (st *NaiveStrategy) RelayPackets(ctx context.Context, src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*RelayMsgs, error) { logger := GetChannelPairLogger(src, dst) defer logger.TimeTrack(time.Now(), "RelayPackets", "num_src", len(rp.Src), "num_dst", len(rp.Dst)) @@ -392,6 +461,22 @@ func (st *NaiveStrategy) UnrelayedAcknowledgements(ctx context.Context, src, dst // TODO add packet-timeout support func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoList, signer sdk.AccAddress) ([]sdk.Msg, error) { logger := GetChannelLogger(chain) + + var nextSequenceRecv uint64 + for _, p := range packets { + if p.Sort == "timeout" { + res, err := chain.QueryNextSequenceReceive(ctx) + if err != nil { + logger.Error("failed to QueryNextSequenceReceive", err, + "height", ctx.Height(), + ) + return nil, err + } + nextSequenceRecv = res.NextSequenceReceive + break + } + } + var msgs []sdk.Msg for _, p := range packets { commitment := chantypes.CommitPacket(chain.Codec(), &p.Packet) @@ -405,7 +490,12 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoLi ) return nil, err } - msg := chantypes.NewMsgRecvPacket(p.Packet, proof, proofHeight, signer.String()) + var msg sdk.Msg + if p.Sort == "timeout" { + msg = chantypes.NewMsgTimeout(p.Packet, nextSequenceRecv, proof, proofHeight, signer.String()) + } else { + msg = chantypes.NewMsgRecvPacket(p.Packet, proof, proofHeight, signer.String()) + } msgs = append(msgs, msg) } return msgs, nil diff --git a/core/service.go b/core/service.go index 12a62bdb..9a19f52f 100644 --- a/core/service.go +++ b/core/service.go @@ -119,6 +119,12 @@ func (srv *RelayService) Serve(ctx context.Context) error { return err } + pseqs2, err := srv.st.SortUnrelayedPackets(srv.src, srv.dst, srv.sh, pseqs) + if err != nil { + logger.Error("failed to sort unrelayed packets", err) + return err + } + // get unrelayed acks aseqs, err := srv.st.UnrelayedAcknowledgements(ctx, srv.src, srv.dst, srv.sh, false) if err != nil { @@ -128,7 +134,7 @@ func (srv *RelayService) Serve(ctx context.Context) error { msgs := NewRelayMsgs() - doExecuteRelaySrc, doExecuteRelayDst := srv.shouldExecuteRelay(ctx, pseqs) + doExecuteRelaySrc, doExecuteRelayDst := srv.shouldExecuteRelay(ctx, pseqs2) doExecuteAckSrc, doExecuteAckDst := srv.shouldExecuteRelay(ctx, aseqs) // update clients if m, err := srv.st.UpdateClients(ctx, srv.src, srv.dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, srv.sh, true); err != nil { @@ -139,7 +145,7 @@ func (srv *RelayService) Serve(ctx context.Context) error { } // relay packets if unrelayed seqs exist - if m, err := srv.st.RelayPackets(ctx, srv.src, srv.dst, pseqs, srv.sh, doExecuteRelaySrc, doExecuteRelayDst); err != nil { + if m, err := srv.st.RelayPackets(ctx, srv.src, srv.dst, pseqs2, srv.sh, doExecuteRelaySrc, doExecuteRelayDst); err != nil { logger.Error("failed to relay packets", err) return err } else { diff --git a/core/strategies.go b/core/strategies.go index e070ab9a..cceba04f 100644 --- a/core/strategies.go +++ b/core/strategies.go @@ -24,6 +24,9 @@ type StrategyI interface { // `includeRelayedButUnfinalized` decides if the result includes packets of which acknowledgePacket has been executed but not finalized UnrelayedAcknowledgements(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) + // SortUnrelayedPackets sorts given RelayPackets and returns sorted RelayPackets. Note that input Packet object may be modified. + SortUnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) + // RelayAcknowledgements executes AcknowledgePacket to the packets contained in `rp` on both chains (`src` and `dst`). RelayAcknowledgements(ctx context.Context, src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*RelayMsgs, error) diff --git a/core/types.go b/core/types.go index d5a520ed..5cedbe54 100644 --- a/core/types.go +++ b/core/types.go @@ -13,6 +13,7 @@ type PacketInfo struct { chantypes.Packet Acknowledgement []byte `json:"acknowledgement"` EventHeight clienttypes.Height `json:"event_height"` + Sort string `json:"sort"` } // PacketInfoList represents a list of PacketInfo that is sorted in the order in which From f9a9f33ecf5329f1c19307460dff43b82a53c1c8 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 17 Mar 2025 04:24:59 +0000 Subject: [PATCH 05/14] rebased Signed-off-by: Daisuke Kanda --- core/chain_testmock.go | 60 ++++++++++++++++++++++++++++++++++++++++++ core/naive-strategy.go | 2 +- core/service.go | 2 +- core/service_test.go | 35 ++++++++++++++---------- core/strategies.go | 2 +- 5 files changed, 84 insertions(+), 17 deletions(-) diff --git a/core/chain_testmock.go b/core/chain_testmock.go index f4cae451..6a76b949 100644 --- a/core/chain_testmock.go +++ b/core/chain_testmock.go @@ -298,6 +298,21 @@ func (mr *MockChainMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockChain)(nil).QueryDenomTraces), ctx, offset, limit) } +// QueryNextSequenceReceive mocks base method. +func (m *MockChain) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockChainMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockChain)(nil).QueryNextSequenceReceive), ctx) +} + // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockChain) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() @@ -677,6 +692,21 @@ func (mr *MockIBCQuerierMockRecorder) QueryConnection(ctx, connectionID any) *go return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockIBCQuerier)(nil).QueryConnection), ctx, connectionID) } +// QueryNextSequenceReceive mocks base method. +func (m *MockIBCQuerier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockIBCQuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockIBCQuerier)(nil).QueryNextSequenceReceive), ctx) +} + // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockIBCQuerier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() @@ -914,6 +944,21 @@ func (mr *MockICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannelUpgradeError), ctx) } +// QueryNextSequenceReceive mocks base method. +func (m *MockICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockICS04Querier)(nil).QueryNextSequenceReceive), ctx) +} + // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() @@ -1158,6 +1203,21 @@ func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannelUpgradeError), ctx) } +// QueryNextSequenceReceive mocks base method. +func (m *MockLightClientICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) + ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. +func (mr *MockLightClientICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryNextSequenceReceive), ctx) +} + // QueryUnfinalizedRelayAcknowledgements mocks base method. func (m *MockLightClientICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { m.ctrl.T.Helper() diff --git a/core/naive-strategy.go b/core/naive-strategy.go index 550270da..8c4d1ff3 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -200,7 +200,7 @@ func (st *NaiveStrategy) UnrelayedPackets(ctx context.Context, src, dst *Provabl }, nil } -func (st *NaiveStrategy) SortUnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) { +func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) { logger := GetChannelPairLogger(src, dst) var ( srcPackets PacketInfoList diff --git a/core/service.go b/core/service.go index 9a19f52f..7028573a 100644 --- a/core/service.go +++ b/core/service.go @@ -119,7 +119,7 @@ func (srv *RelayService) Serve(ctx context.Context) error { return err } - pseqs2, err := srv.st.SortUnrelayedPackets(srv.src, srv.dst, srv.sh, pseqs) + pseqs2, err := srv.st.SortUnrelayedPackets(ctx, srv.src, srv.dst, srv.sh, pseqs) if err != nil { logger.Error("failed to sort unrelayed packets", err) return err diff --git a/core/service_test.go b/core/service_test.go index e4af38a1..56388a13 100644 --- a/core/service_test.go +++ b/core/service_test.go @@ -27,6 +27,7 @@ type NaiveStrategyWrap struct { Inner *core.NaiveStrategy UnrelayedPacketsOut *core.RelayPackets + SortUnrelayedPacketsOut *core.RelayPackets UnrelayedAcknowledgementsOut *core.RelayPackets RelayPacketsOut *core.RelayMsgs RelayAcknowledgementsOut *core.RelayMsgs @@ -35,35 +36,41 @@ type NaiveStrategyWrap struct { } func (s *NaiveStrategyWrap) GetType() string { return s.Inner.GetType() } func (s *NaiveStrategyWrap) SetupRelay(ctx context.Context, src, dst *core.ProvableChain) error { return s.Inner.SetupRelay(ctx, src, dst) } -func (s *NaiveStrategyWrap) UnrelayedPackets(src, dst *core.ProvableChain, sh core.SyncHeaders, includeRelayedButUnfinalized bool) (*core.RelayPackets, error) { - ret, err := s.Inner.UnrelayedPackets(src, dst, sh, includeRelayedButUnfinalized) +func (s *NaiveStrategyWrap) UnrelayedPackets(ctx context.Context, src, dst *core.ProvableChain, sh core.SyncHeaders, includeRelayedButUnfinalized bool) (*core.RelayPackets, error) { + ret, err := s.Inner.UnrelayedPackets(ctx, src, dst, sh, includeRelayedButUnfinalized) s.UnrelayedPacketsOut = ret return ret, err } -func (s *NaiveStrategyWrap) RelayPackets(src, dst *core.ProvableChain, rp *core.RelayPackets, sh core.SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*core.RelayMsgs, error) { - ret, err := s.Inner.RelayPackets(src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) + +func (s *NaiveStrategyWrap) SortUnrelayedPackets(ctx context.Context, src, dst *core.ProvableChain, sh core.SyncHeaders, rp *core.RelayPackets) (*core.RelayPackets, error) { + ret, err := s.Inner.SortUnrelayedPackets(ctx, src, dst, sh, rp) + s.SortUnrelayedPacketsOut = ret + return ret, err +} + +func (s *NaiveStrategyWrap) RelayPackets(ctx context.Context, src, dst *core.ProvableChain, rp *core.RelayPackets, sh core.SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*core.RelayMsgs, error) { + ret, err := s.Inner.RelayPackets(ctx, src, dst, rp, sh, doExecuteRelaySrc, doExecuteRelayDst) s.RelayPacketsOut = ret return ret, err } -func (s *NaiveStrategyWrap) UnrelayedAcknowledgements(src, dst *core.ProvableChain, sh core.SyncHeaders, includeRelayedButUnfinalized bool) (*core.RelayPackets, error) { - ret, err := s.Inner.UnrelayedAcknowledgements(src, dst, sh, includeRelayedButUnfinalized) +func (s *NaiveStrategyWrap) UnrelayedAcknowledgements(ctx context.Context, src, dst *core.ProvableChain, sh core.SyncHeaders, includeRelayedButUnfinalized bool) (*core.RelayPackets, error) { + ret, err := s.Inner.UnrelayedAcknowledgements(ctx, src, dst, sh, includeRelayedButUnfinalized) s.UnrelayedAcknowledgementsOut = ret return ret, err } -func (s *NaiveStrategyWrap) RelayAcknowledgements(src, dst *core.ProvableChain, rp *core.RelayPackets, sh core.SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*core.RelayMsgs, error) { - ret, err := s.Inner.RelayAcknowledgements(src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) +func (s *NaiveStrategyWrap) RelayAcknowledgements(ctx context.Context, src, dst *core.ProvableChain, rp *core.RelayPackets, sh core.SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*core.RelayMsgs, error) { + ret, err := s.Inner.RelayAcknowledgements(ctx, src, dst, rp, sh, doExecuteAckSrc, doExecuteAckDst) s.RelayAcknowledgementsOut = ret return ret, err } -func (s *NaiveStrategyWrap) UpdateClients(src, dst *core.ProvableChain, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst bool, sh core.SyncHeaders, doRefresh bool) (*core.RelayMsgs, error) { - ret, err := s.Inner.UpdateClients(src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) - fmt.Printf("UpdateClients: %v, %v, %v, %v, %v\n", doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, doRefresh) +func (s *NaiveStrategyWrap) UpdateClients(ctx context.Context, src, dst *core.ProvableChain, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst bool, sh core.SyncHeaders, doRefresh bool) (*core.RelayMsgs, error) { + ret, err := s.Inner.UpdateClients(ctx, src, dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, sh, doRefresh) s.UpdateClientsOut = ret return ret, err } -func (s *NaiveStrategyWrap) Send(src, dst core.Chain, msgs *core.RelayMsgs) { +func (s *NaiveStrategyWrap) Send(ctx context.Context, src, dst core.Chain, msgs *core.RelayMsgs) { s.SendIn = msgs - s.Inner.Send(src, dst, msgs) + s.Inner.Send(ctx, src, dst, msgs) } func NewMockProvableChain( @@ -189,7 +196,7 @@ func testServe(t *testing.T, tc testCase) { dst := NewMockProvableChain(ctrl, "dst", tc.Order, dstLatestHeader, []*core.PacketInfo{}, unreceivedPackets) st := &NaiveStrategyWrap{ Inner: core.NewNaiveStrategy(false, false) } - sh, err := core.NewSyncHeaders(src, dst) + sh, err := core.NewSyncHeaders(context.TODO(), src, dst) if err != nil { fmt.Printf("NewSyncHeders: %v\n", err) } diff --git a/core/strategies.go b/core/strategies.go index cceba04f..e4e9f869 100644 --- a/core/strategies.go +++ b/core/strategies.go @@ -25,7 +25,7 @@ type StrategyI interface { UnrelayedAcknowledgements(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) // SortUnrelayedPackets sorts given RelayPackets and returns sorted RelayPackets. Note that input Packet object may be modified. - SortUnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) + SortUnrelayedPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) // RelayAcknowledgements executes AcknowledgePacket to the packets contained in `rp` on both chains (`src` and `dst`). RelayAcknowledgements(ctx context.Context, src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*RelayMsgs, error) From 7398bcb51fc089d4fc1e149836ba558ebbe57f5c Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 17 Mar 2025 09:32:13 +0000 Subject: [PATCH 06/14] add test for timeout Signed-off-by: Daisuke Kanda --- core/naive-strategy.go | 4 +- core/service_test.go | 140 +++++++++++++++++++++++++++++------------ 2 files changed, 102 insertions(+), 42 deletions(-) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index 8c4d1ff3..bc16b2ac 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -212,7 +212,7 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro ) if 0 < len(rp.Src) { - dstHeight := sh.GetLatestFinalizedHeader(dst.ChainID()).GetHeight() + dstHeight = sh.GetLatestFinalizedHeader(dst.ChainID()).GetHeight() timestamp, err := dst.Timestamp(context.TODO(), dstHeight) if err != nil { logger.Error("fail to get dst.Timestamp", err) @@ -221,7 +221,7 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro dstTimestamp = uint64(timestamp.UnixNano()) } if 0 < len(rp.Dst) { - srcHeight := sh.GetLatestFinalizedHeader(src.ChainID()).GetHeight() + srcHeight = sh.GetLatestFinalizedHeader(src.ChainID()).GetHeight() timestamp, err := src.Timestamp(context.TODO(), srcHeight) if err != nil { logger.Error("fail to get src.Timestamp", err) diff --git a/core/service_test.go b/core/service_test.go index 56388a13..3d35386b 100644 --- a/core/service_test.go +++ b/core/service_test.go @@ -3,6 +3,7 @@ package core_test import ( "testing" "go.uber.org/mock/gomock" + "github.com/stretchr/testify/assert" "time" "context" @@ -32,7 +33,8 @@ type NaiveStrategyWrap struct { RelayPacketsOut *core.RelayMsgs RelayAcknowledgementsOut *core.RelayMsgs UpdateClientsOut *core.RelayMsgs - SendIn *core.RelayMsgs + SendInSrc []string + SendInDst []string } func (s *NaiveStrategyWrap) GetType() string { return s.Inner.GetType() } func (s *NaiveStrategyWrap) SetupRelay(ctx context.Context, src, dst *core.ProvableChain) error { return s.Inner.SetupRelay(ctx, src, dst) } @@ -69,10 +71,41 @@ func (s *NaiveStrategyWrap) UpdateClients(ctx context.Context, src, dst *core.Pr return ret, err } func (s *NaiveStrategyWrap) Send(ctx context.Context, src, dst core.Chain, msgs *core.RelayMsgs) { - s.SendIn = msgs + // format message object as string to be easily comparable + format := func(msgs []sdk.Msg) ([]string) { + ret := []string{} + for _, msg := range msgs { + typeof := reflect.TypeOf(msg).Elem().Name() + var desc string + switch typeof { + case "MsgUpdateClient": + m := msg.(*clienttypes.MsgUpdateClient) + desc = fmt.Sprintf("%s(%s)", typeof, m.ClientId) + case "MsgRecvPacket": + m := msg.(*chantypes.MsgRecvPacket) + desc = fmt.Sprintf("%s(%v)", typeof, m.Packet.GetSequence()) + case "MsgTimeout": + m := msg.(*chantypes.MsgTimeout) + desc = fmt.Sprintf("%s(%v)", typeof, m.Packet.GetSequence()) + default: + desc = fmt.Sprintf("%s()", typeof) + } + ret = append(ret, desc) + } + return ret + } + s.SendInSrc = format(msgs.Src) + s.SendInDst = format(msgs.Dst) s.Inner.Send(ctx, src, dst, msgs) } +/** + * create mock ProvableChain with our MockProver and gomock's MockChain. + * about height: + * LatestHeight: returns header that NewMockProvableChain is given + * LatestFinalizedHeight: LatestHeight - 10 + * Timestamp: height + 10000 + */ func NewMockProvableChain( ctrl *gomock.Controller, name, order string, @@ -100,10 +133,15 @@ func NewMockProvableChain( func(ctx context.Context, h ibcexported.Height) (time.Time, error) { return time.Unix(0, int64(10000 + h.GetRevisionHeight())), nil }).AnyTimes() + chain.EXPECT().QueryNextSequenceReceive(gomock.Any()).DoAndReturn( + func(ctx core.QueryContext) (*chantypes.QueryNextSequenceReceiveResponse, error) { + height := ctx.Height().(clienttypes.Height) + return &chantypes.QueryNextSequenceReceiveResponse{ 1, []byte{}, height }, nil + }).AnyTimes() chain.EXPECT().QueryUnfinalizedRelayPackets(gomock.Any(), gomock.Any()).Return(unfinalizedRelayPackets, nil) chain.EXPECT().QueryUnreceivedPackets(gomock.Any(), gomock.Any()).Return(unreceivedPackets, nil).AnyTimes() - chain.EXPECT().QueryUnfinalizedRelayAcknowledgements(gomock.Any(), gomock.Any()).Return([]*core.PacketInfo{}, nil).AnyTimes() chain.EXPECT().QueryUnreceivedAcknowledgements(gomock.Any(), gomock.Any()).Return([]uint64{}, nil).AnyTimes() + chain.EXPECT().QueryUnfinalizedRelayAcknowledgements(gomock.Any(), gomock.Any()).Return([]*core.PacketInfo{}, nil).AnyTimes() chain.EXPECT().SendMsgs(gomock.Any(), gomock.Any()).DoAndReturn(func(ctx context.Context, msgs []sdk.Msg) ([]core.MsgID, error) { var msgIDs []core.MsgID for _, _ = range msgs { @@ -116,9 +154,10 @@ func NewMockProvableChain( type testCase struct { Order string - dstOptimizeCount uint64 + optimizeCount uint64 UnfinalizedRelayPackets core.PacketInfoList - ExpectSend []string + ExpectSendSrc []string + ExpectSendDst []string } func newPacketInfo(seq uint64, timeoutHeight uint64) (*core.PacketInfo) { @@ -131,7 +170,7 @@ func newPacketInfo(seq uint64, timeoutHeight uint64) (*core.PacketInfo) { "dstPort", "dstChannel", clienttypes.NewHeight(1, timeoutHeight), - ^uint64(0), + 0, // timeoutTimestamp ), EventHeight: clienttypes.NewHeight(1, 1), } @@ -143,27 +182,68 @@ func TestServe(t *testing.T) { "ORDERED", 1, []*core.PacketInfo{}, + []string{ }, + []string{ }, + }, + "single": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 9999), + }, + []string{ }, []string{ + "MsgUpdateClient(dstClient)", + "MsgRecvPacket(1)", }, }, - "single": { + "multi": { "ORDERED", 1, []*core.PacketInfo{ - newPacketInfo(1, 99999), + newPacketInfo(1, 9999), + newPacketInfo(2, 9999), + newPacketInfo(3, 9999), }, + []string{ }, []string{ "MsgUpdateClient(dstClient)", "MsgRecvPacket(1)", + "MsgRecvPacket(2)", + "MsgRecvPacket(3)", }, }, "queued": { "ORDERED", 9, []*core.PacketInfo{ - newPacketInfo(1, 99999), + newPacketInfo(1, 9999), + }, + []string{ }, + []string{ }, + }, + "timeout": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 9), }, + []string{ "MsgUpdateClient(srcClient)", "MsgTimeout(1)" }, + []string{ }, + }, + "only packets precede timeout packet": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 9999), + newPacketInfo(2, 9999), + newPacketInfo(3, 9), + }, + []string{ }, []string{ + "MsgUpdateClient(dstClient)", + "MsgRecvPacket(1)", + "MsgRecvPacket(2)", }, }, } @@ -178,12 +258,12 @@ func testServe(t *testing.T, tc testCase) { metrics.InitializeMetrics(metrics.ExporterNull{}) srcLatestHeader := mocktypes.Header{ - Height: clienttypes.NewHeight(10, 99), - Timestamp: uint64(10099), + Height: clienttypes.NewHeight(1, 100), + Timestamp: uint64(10100), } dstLatestHeader := mocktypes.Header{ - Height: clienttypes.NewHeight(110, 199), - Timestamp: uint64(10199), + Height: clienttypes.NewHeight(1, 100), + Timestamp: uint64(10100), } ctrl := gomock.NewController(t) @@ -201,38 +281,18 @@ func testServe(t *testing.T, tc testCase) { fmt.Printf("NewSyncHeders: %v\n", err) } var forever time.Duration = 1 << 63 - 1 - srv := core.NewRelayService(st, src, dst, sh, time.Minute, forever, 1, forever, tc.dstOptimizeCount) + srv := core.NewRelayService(st, src, dst, sh, time.Minute, forever, tc.optimizeCount, forever, tc.optimizeCount) srv.Serve(context.TODO()) + /* for debug fmt.Printf("UnrelayedPackets: %v\n", st.UnrelayedPacketsOut) fmt.Printf("UnrelayedAcknowledgementsOut: %v\n", st.UnrelayedAcknowledgementsOut) fmt.Printf("RelayPacketsOut: %v\n", st.RelayPacketsOut) fmt.Printf("RelayAcknowledgementsOut: %v\n", st.RelayAcknowledgementsOut) fmt.Printf("UpdateClientsOut: %v\n", st.UpdateClientsOut) - fmt.Printf("Send.Src: %v\n", st.SendIn.Src) - fmt.Printf("Send.Dst: %v\n", st.SendIn.Dst) - if len(st.SendIn.Dst) != len(tc.ExpectSend) { - t.Fatal(fmt.Sprintf("sendExpect size mismatch: %v but %v", len(tc.ExpectSend), len(st.SendIn.Dst))) - } - for i, msg := range st.SendIn.Dst { - //fmt.Printf(" %v: %v\n", i, proto.MessaageName(msg)) - typeof := reflect.TypeOf(msg).Elem().Name() - var desc string - switch typeof { - case "MsgUpdateClient": - m := msg.(*clienttypes.MsgUpdateClient) - desc = fmt.Sprintf("%s(%s)", typeof, m.ClientId) - case"MsgRecvPacket": - m := msg.(*chantypes.MsgRecvPacket) - desc = fmt.Sprintf("%s(%v)", typeof, m.Packet.GetSequence()) - case"MsgTimeout": - m := msg.(*chantypes.MsgTimeout) - desc = fmt.Sprintf("%s(%v)", typeof, m.Packet.GetSequence()) - default: - desc = fmt.Sprintf("%s()", typeof) - } - if desc != tc.ExpectSend[i] { - t.Fatal(fmt.Sprintf("send mismatch at %v: '%s' but '%s'", i, tc.ExpectSend[i], desc)) - } - } + fmt.Printf("Send.Src: %v\n", st.SendInSrc) + fmt.Printf("Send.Dst: %v\n", st.SendInDst) + */ + assert.Equal(t, tc.ExpectSendSrc, st.SendInSrc, "Send.Src") + assert.Equal(t, tc.ExpectSendDst, st.SendInDst, "Send.Dst") } From 151393982dd0cb43b62e8042cb89372245548390 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Tue, 18 Mar 2025 09:49:09 +0000 Subject: [PATCH 07/14] sort timeout packet in relay cmd Signed-off-by: Daisuke Kanda --- cmd/tx.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/cmd/tx.go b/cmd/tx.go index 949dc5be..af42e28f 100644 --- a/cmd/tx.go +++ b/cmd/tx.go @@ -457,6 +457,11 @@ func relayMsgsCmd(ctx *config.Context) *cobra.Command { return err } + sp, err = st.SortUnrelayedPackets(cmd.Context(), c[src], c[dst], sh, sp) + if err != nil { + return err + } + msgs := core.NewRelayMsgs() doExecuteRelaySrc := len(sp.Dst) > 0 From 452ee8a4e0ce5cf3e8ccdd30659194d164609b96 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 24 Mar 2025 09:46:17 +0000 Subject: [PATCH 08/14] use absense proof for timeout Signed-off-by: Daisuke Kanda --- core/naive-strategy.go | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index bc16b2ac..50b59418 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -479,21 +479,32 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoLi var msgs []sdk.Msg for _, p := range packets { - commitment := chantypes.CommitPacket(chain.Codec(), &p.Packet) - path := host.PacketCommitmentPath(p.SourcePort, p.SourceChannel, p.Sequence) - proof, proofHeight, err := chain.ProveState(ctx, path, commitment) - if err != nil { - logger.Error("failed to ProveState", err, - "height", ctx.Height(), - "path", path, - "commitment", commitment, - ) - return nil, err - } var msg sdk.Msg if p.Sort == "timeout" { + path := host.PacketReceiptPath(p.SourcePort, p.SourceChannel, p.Sequence) + commitment := []byte{} //ABSENSE + proof, proofHeight, err := chain.ProveState(ctx, path, commitment) + if err != nil { + logger.Error("failed to ProveState", err, + "height", ctx.Height(), + "path", path, + "commitment", commitment, + ) + return nil, err + } msg = chantypes.NewMsgTimeout(p.Packet, nextSequenceRecv, proof, proofHeight, signer.String()) } else { + path := host.PacketCommitmentPath(p.SourcePort, p.SourceChannel, p.Sequence) + commitment := chantypes.CommitPacket(chain.Codec(), &p.Packet) + proof, proofHeight, err := chain.ProveState(ctx, path, commitment) + if err != nil { + logger.Error("failed to ProveState", err, + "height", ctx.Height(), + "path", path, + "commitment", commitment, + ) + return nil, err + } msg = chantypes.NewMsgRecvPacket(p.Packet, proof, proofHeight, signer.String()) } msgs = append(msgs, msg) From b103439e3ca64a0e3c7b6886007c8fb4c6165136 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Tue, 25 Mar 2025 02:36:34 +0000 Subject: [PATCH 09/14] fix proof of ordered timeout Signed-off-by: Daisuke Kanda --- core/naive-strategy.go | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index 50b59418..c512cf9e 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -5,6 +5,7 @@ import ( "fmt" "log/slog" "time" + "encoding/binary" retry "github.com/avast/retry-go" sdk "github.com/cosmos/cosmos-sdk/types" @@ -481,8 +482,17 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoLi for _, p := range packets { var msg sdk.Msg if p.Sort == "timeout" { - path := host.PacketReceiptPath(p.SourcePort, p.SourceChannel, p.Sequence) - commitment := []byte{} //ABSENSE + // make path of original packet's destination port and channel + var path string + var commitment []byte + if chain.Path().GetOrder() == chantypes.ORDERED { + path = host.NextSequenceRecvPath(p.SourcePort, p.SourceChannel) + commitment = make([]byte, 8) + binary.BigEndian.PutUint64(commitment[0:], nextSequenceRecv) + } else { + path = host.PacketReceiptPath(p.SourcePort, p.SourceChannel, p.Sequence) + commitment = []byte{} //ABSENSE + } proof, proofHeight, err := chain.ProveState(ctx, path, commitment) if err != nil { logger.Error("failed to ProveState", err, From ffdce65fa055691531ba9a3a0420a942b63ae7c3 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Fri, 28 Mar 2025 09:03:06 +0000 Subject: [PATCH 10/14] set NextSequenceRecv of TimeoutPacket not zero in unordered channel Signed-off-by: Daisuke Kanda --- core/naive-strategy.go | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index c512cf9e..bcd00cce 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -464,18 +464,23 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoLi logger := GetChannelLogger(chain) var nextSequenceRecv uint64 - for _, p := range packets { - if p.Sort == "timeout" { - res, err := chain.QueryNextSequenceReceive(ctx) - if err != nil { - logger.Error("failed to QueryNextSequenceReceive", err, - "height", ctx.Height(), - ) - return nil, err + if chain.Path().GetOrder() == chantypes.ORDERED { + for _, p := range packets { + if p.Sort == "timeout" { + res, err := chain.QueryNextSequenceReceive(ctx) + if err != nil { + logger.Error("failed to QueryNextSequenceReceive", err, + "height", ctx.Height(), + ) + return nil, err + } + nextSequenceRecv = res.NextSequenceReceive + break } - nextSequenceRecv = res.NextSequenceReceive - break } + } else { + // nextSequenceRecv has no effect in unordered channel but ibc-go expect it is not zero. + nextSequenceRecv = 1 } var msgs []sdk.Msg From f33563cb8d609b4bf5ffb5785b958d6ab8342f14 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 31 Mar 2025 07:15:21 +0000 Subject: [PATCH 11/14] rename testmock.go to _test.go Signed-off-by: Daisuke Kanda --- Makefile | 2 +- core/chain.go | 2 +- core/chain_testmock.go | 1346 ---------------------------------------- 3 files changed, 2 insertions(+), 1348 deletions(-) delete mode 100644 core/chain_testmock.go diff --git a/Makefile b/Makefile index e284f468..f53175f9 100644 --- a/Makefile +++ b/Makefile @@ -8,7 +8,7 @@ protoImage=$(DOCKER) run --user 0 --rm -v $(CURDIR):/workspace --workdir /worksp build: go build -o ./build/yrly . -TESTMOCKS = core/chain_testmock.go +TESTMOCKS = core/mock_chain_test.go .PHONY: test test: $(TESTMOCKS) go test -v ./... diff --git a/core/chain.go b/core/chain.go index 239a9f9d..0ba8a411 100644 --- a/core/chain.go +++ b/core/chain.go @@ -55,7 +55,7 @@ func (pc *ProvableChain) SetupForRelay(ctx context.Context) error { return nil } -//go:generate mockgen -source=chain.go -destination=chain_testmock.go -package core +//go:generate mockgen -source=chain.go -destination=mock_chain_test.go -package core // Chain represents a chain that supports sending transactions and querying the state type Chain interface { // GetAddress returns the address of relayer diff --git a/core/chain_testmock.go b/core/chain_testmock.go deleted file mode 100644 index 6a76b949..00000000 --- a/core/chain_testmock.go +++ /dev/null @@ -1,1346 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: chain.go -// -// Generated by this command: -// -// mockgen -source=chain.go -destination=chain_testmock.go -package core -// - -// Package core is a generated GoMock package. -package core - -import ( - context "context" - reflect "reflect" - time "time" - - codec "github.com/cosmos/cosmos-sdk/codec" - types "github.com/cosmos/cosmos-sdk/types" - types0 "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types" - types1 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" - types2 "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types" - types3 "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types" - exported "github.com/cosmos/ibc-go/v8/modules/core/exported" - gomock "go.uber.org/mock/gomock" -) - -// MockChain is a mock of Chain interface. -type MockChain struct { - ctrl *gomock.Controller - recorder *MockChainMockRecorder - isgomock struct{} -} - -// MockChainMockRecorder is the mock recorder for MockChain. -type MockChainMockRecorder struct { - mock *MockChain -} - -// NewMockChain creates a new mock instance. -func NewMockChain(ctrl *gomock.Controller) *MockChain { - mock := &MockChain{ctrl: ctrl} - mock.recorder = &MockChainMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockChain) EXPECT() *MockChainMockRecorder { - return m.recorder -} - -// AverageBlockTime mocks base method. -func (m *MockChain) AverageBlockTime() time.Duration { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AverageBlockTime") - ret0, _ := ret[0].(time.Duration) - return ret0 -} - -// AverageBlockTime indicates an expected call of AverageBlockTime. -func (mr *MockChainMockRecorder) AverageBlockTime() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChain)(nil).AverageBlockTime)) -} - -// ChainID mocks base method. -func (m *MockChain) ChainID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ChainID") - ret0, _ := ret[0].(string) - return ret0 -} - -// ChainID indicates an expected call of ChainID. -func (mr *MockChainMockRecorder) ChainID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChain)(nil).ChainID)) -} - -// Codec mocks base method. -func (m *MockChain) Codec() codec.ProtoCodecMarshaler { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Codec") - ret0, _ := ret[0].(codec.ProtoCodecMarshaler) - return ret0 -} - -// Codec indicates an expected call of Codec. -func (mr *MockChainMockRecorder) Codec() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Codec", reflect.TypeOf((*MockChain)(nil).Codec)) -} - -// GetAddress mocks base method. -func (m *MockChain) GetAddress() (types.AccAddress, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAddress") - ret0, _ := ret[0].(types.AccAddress) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAddress indicates an expected call of GetAddress. -func (mr *MockChainMockRecorder) GetAddress() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockChain)(nil).GetAddress)) -} - -// GetMsgResult mocks base method. -func (m *MockChain) GetMsgResult(ctx context.Context, id MsgID) (MsgResult, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMsgResult", ctx, id) - ret0, _ := ret[0].(MsgResult) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMsgResult indicates an expected call of GetMsgResult. -func (mr *MockChainMockRecorder) GetMsgResult(ctx, id any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMsgResult", reflect.TypeOf((*MockChain)(nil).GetMsgResult), ctx, id) -} - -// Init mocks base method. -func (m *MockChain) Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Init", homePath, timeout, codec, debug) - ret0, _ := ret[0].(error) - return ret0 -} - -// Init indicates an expected call of Init. -func (mr *MockChainMockRecorder) Init(homePath, timeout, codec, debug any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockChain)(nil).Init), homePath, timeout, codec, debug) -} - -// LatestHeight mocks base method. -func (m *MockChain) LatestHeight(ctx context.Context) (exported.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestHeight", ctx) - ret0, _ := ret[0].(exported.Height) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LatestHeight indicates an expected call of LatestHeight. -func (mr *MockChainMockRecorder) LatestHeight(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChain)(nil).LatestHeight), ctx) -} - -// Path mocks base method. -func (m *MockChain) Path() *PathEnd { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Path") - ret0, _ := ret[0].(*PathEnd) - return ret0 -} - -// Path indicates an expected call of Path. -func (mr *MockChainMockRecorder) Path() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockChain)(nil).Path)) -} - -// QueryBalance mocks base method. -func (m *MockChain) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryBalance", ctx, address) - ret0, _ := ret[0].(types.Coins) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryBalance indicates an expected call of QueryBalance. -func (mr *MockChainMockRecorder) QueryBalance(ctx, address any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockChain)(nil).QueryBalance), ctx, address) -} - -// QueryCanTransitionToFlushComplete mocks base method. -func (m *MockChain) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. -func (mr *MockChainMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockChain)(nil).QueryCanTransitionToFlushComplete), ctx) -} - -// QueryChannel mocks base method. -func (m *MockChain) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannel", ctx) - ret0, _ := ret[0].(*types3.QueryChannelResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannel indicates an expected call of QueryChannel. -func (mr *MockChainMockRecorder) QueryChannel(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockChain)(nil).QueryChannel), ctx) -} - -// QueryChannelUpgrade mocks base method. -func (m *MockChain) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. -func (mr *MockChainMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockChain)(nil).QueryChannelUpgrade), ctx) -} - -// QueryChannelUpgradeError mocks base method. -func (m *MockChain) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. -func (mr *MockChainMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockChain)(nil).QueryChannelUpgradeError), ctx) -} - -// QueryClientConsensusState mocks base method. -func (m *MockChain) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) - ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. -func (mr *MockChainMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockChain)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) -} - -// QueryClientState mocks base method. -func (m *MockChain) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientState", ctx) - ret0, _ := ret[0].(*types1.QueryClientStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientState indicates an expected call of QueryClientState. -func (mr *MockChainMockRecorder) QueryClientState(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockChain)(nil).QueryClientState), ctx) -} - -// QueryConnection mocks base method. -func (m *MockChain) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) - ret0, _ := ret[0].(*types2.QueryConnectionResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryConnection indicates an expected call of QueryConnection. -func (mr *MockChainMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockChain)(nil).QueryConnection), ctx, connectionID) -} - -// QueryDenomTraces mocks base method. -func (m *MockChain) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) - ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryDenomTraces indicates an expected call of QueryDenomTraces. -func (mr *MockChainMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockChain)(nil).QueryDenomTraces), ctx, offset, limit) -} - -// QueryNextSequenceReceive mocks base method. -func (m *MockChain) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockChainMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockChain)(nil).QueryNextSequenceReceive), ctx) -} - -// QueryUnfinalizedRelayAcknowledgements mocks base method. -func (m *MockChain) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. -func (mr *MockChainMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockChain)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) -} - -// QueryUnfinalizedRelayPackets mocks base method. -func (m *MockChain) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. -func (mr *MockChainMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockChain)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) -} - -// QueryUnreceivedAcknowledgements mocks base method. -func (m *MockChain) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. -func (mr *MockChainMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockChain)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) -} - -// QueryUnreceivedPackets mocks base method. -func (m *MockChain) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. -func (mr *MockChainMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockChain)(nil).QueryUnreceivedPackets), ctx, seqs) -} - -// RegisterMsgEventListener mocks base method. -func (m *MockChain) RegisterMsgEventListener(arg0 MsgEventListener) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterMsgEventListener", arg0) -} - -// RegisterMsgEventListener indicates an expected call of RegisterMsgEventListener. -func (mr *MockChainMockRecorder) RegisterMsgEventListener(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMsgEventListener", reflect.TypeOf((*MockChain)(nil).RegisterMsgEventListener), arg0) -} - -// SendMsgs mocks base method. -func (m *MockChain) SendMsgs(ctx context.Context, msgs []types.Msg) ([]MsgID, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendMsgs", ctx, msgs) - ret0, _ := ret[0].([]MsgID) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendMsgs indicates an expected call of SendMsgs. -func (mr *MockChainMockRecorder) SendMsgs(ctx, msgs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsgs", reflect.TypeOf((*MockChain)(nil).SendMsgs), ctx, msgs) -} - -// SetRelayInfo mocks base method. -func (m *MockChain) SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRelayInfo", path, counterparty, counterpartyPath) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetRelayInfo indicates an expected call of SetRelayInfo. -func (mr *MockChainMockRecorder) SetRelayInfo(path, counterparty, counterpartyPath any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRelayInfo", reflect.TypeOf((*MockChain)(nil).SetRelayInfo), path, counterparty, counterpartyPath) -} - -// SetupForRelay mocks base method. -func (m *MockChain) SetupForRelay(ctx context.Context) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupForRelay", ctx) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetupForRelay indicates an expected call of SetupForRelay. -func (mr *MockChainMockRecorder) SetupForRelay(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupForRelay", reflect.TypeOf((*MockChain)(nil).SetupForRelay), ctx) -} - -// Timestamp mocks base method. -func (m *MockChain) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Timestamp", ctx, height) - ret0, _ := ret[0].(time.Time) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Timestamp indicates an expected call of Timestamp. -func (mr *MockChainMockRecorder) Timestamp(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChain)(nil).Timestamp), ctx, height) -} - -// MockChainInfo is a mock of ChainInfo interface. -type MockChainInfo struct { - ctrl *gomock.Controller - recorder *MockChainInfoMockRecorder - isgomock struct{} -} - -// MockChainInfoMockRecorder is the mock recorder for MockChainInfo. -type MockChainInfoMockRecorder struct { - mock *MockChainInfo -} - -// NewMockChainInfo creates a new mock instance. -func NewMockChainInfo(ctrl *gomock.Controller) *MockChainInfo { - mock := &MockChainInfo{ctrl: ctrl} - mock.recorder = &MockChainInfoMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockChainInfo) EXPECT() *MockChainInfoMockRecorder { - return m.recorder -} - -// AverageBlockTime mocks base method. -func (m *MockChainInfo) AverageBlockTime() time.Duration { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AverageBlockTime") - ret0, _ := ret[0].(time.Duration) - return ret0 -} - -// AverageBlockTime indicates an expected call of AverageBlockTime. -func (mr *MockChainInfoMockRecorder) AverageBlockTime() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AverageBlockTime", reflect.TypeOf((*MockChainInfo)(nil).AverageBlockTime)) -} - -// ChainID mocks base method. -func (m *MockChainInfo) ChainID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ChainID") - ret0, _ := ret[0].(string) - return ret0 -} - -// ChainID indicates an expected call of ChainID. -func (mr *MockChainInfoMockRecorder) ChainID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainID", reflect.TypeOf((*MockChainInfo)(nil).ChainID)) -} - -// LatestHeight mocks base method. -func (m *MockChainInfo) LatestHeight(ctx context.Context) (exported.Height, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestHeight", ctx) - ret0, _ := ret[0].(exported.Height) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LatestHeight indicates an expected call of LatestHeight. -func (mr *MockChainInfoMockRecorder) LatestHeight(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestHeight", reflect.TypeOf((*MockChainInfo)(nil).LatestHeight), ctx) -} - -// Timestamp mocks base method. -func (m *MockChainInfo) Timestamp(ctx context.Context, height exported.Height) (time.Time, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Timestamp", ctx, height) - ret0, _ := ret[0].(time.Time) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Timestamp indicates an expected call of Timestamp. -func (mr *MockChainInfoMockRecorder) Timestamp(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockChainInfo)(nil).Timestamp), ctx, height) -} - -// MockMsgEventListener is a mock of MsgEventListener interface. -type MockMsgEventListener struct { - ctrl *gomock.Controller - recorder *MockMsgEventListenerMockRecorder - isgomock struct{} -} - -// MockMsgEventListenerMockRecorder is the mock recorder for MockMsgEventListener. -type MockMsgEventListenerMockRecorder struct { - mock *MockMsgEventListener -} - -// NewMockMsgEventListener creates a new mock instance. -func NewMockMsgEventListener(ctrl *gomock.Controller) *MockMsgEventListener { - mock := &MockMsgEventListener{ctrl: ctrl} - mock.recorder = &MockMsgEventListenerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockMsgEventListener) EXPECT() *MockMsgEventListenerMockRecorder { - return m.recorder -} - -// OnSentMsg mocks base method. -func (m *MockMsgEventListener) OnSentMsg(ctx context.Context, msgs []types.Msg) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "OnSentMsg", ctx, msgs) - ret0, _ := ret[0].(error) - return ret0 -} - -// OnSentMsg indicates an expected call of OnSentMsg. -func (mr *MockMsgEventListenerMockRecorder) OnSentMsg(ctx, msgs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnSentMsg", reflect.TypeOf((*MockMsgEventListener)(nil).OnSentMsg), ctx, msgs) -} - -// MockIBCQuerier is a mock of IBCQuerier interface. -type MockIBCQuerier struct { - ctrl *gomock.Controller - recorder *MockIBCQuerierMockRecorder - isgomock struct{} -} - -// MockIBCQuerierMockRecorder is the mock recorder for MockIBCQuerier. -type MockIBCQuerierMockRecorder struct { - mock *MockIBCQuerier -} - -// NewMockIBCQuerier creates a new mock instance. -func NewMockIBCQuerier(ctrl *gomock.Controller) *MockIBCQuerier { - mock := &MockIBCQuerier{ctrl: ctrl} - mock.recorder = &MockIBCQuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockIBCQuerier) EXPECT() *MockIBCQuerierMockRecorder { - return m.recorder -} - -// QueryCanTransitionToFlushComplete mocks base method. -func (m *MockIBCQuerier) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. -func (mr *MockIBCQuerierMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockIBCQuerier)(nil).QueryCanTransitionToFlushComplete), ctx) -} - -// QueryChannel mocks base method. -func (m *MockIBCQuerier) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannel", ctx) - ret0, _ := ret[0].(*types3.QueryChannelResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannel indicates an expected call of QueryChannel. -func (mr *MockIBCQuerierMockRecorder) QueryChannel(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockIBCQuerier)(nil).QueryChannel), ctx) -} - -// QueryChannelUpgrade mocks base method. -func (m *MockIBCQuerier) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. -func (mr *MockIBCQuerierMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockIBCQuerier)(nil).QueryChannelUpgrade), ctx) -} - -// QueryChannelUpgradeError mocks base method. -func (m *MockIBCQuerier) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. -func (mr *MockIBCQuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockIBCQuerier)(nil).QueryChannelUpgradeError), ctx) -} - -// QueryClientConsensusState mocks base method. -func (m *MockIBCQuerier) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) - ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. -func (mr *MockIBCQuerierMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockIBCQuerier)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) -} - -// QueryClientState mocks base method. -func (m *MockIBCQuerier) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientState", ctx) - ret0, _ := ret[0].(*types1.QueryClientStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientState indicates an expected call of QueryClientState. -func (mr *MockIBCQuerierMockRecorder) QueryClientState(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockIBCQuerier)(nil).QueryClientState), ctx) -} - -// QueryConnection mocks base method. -func (m *MockIBCQuerier) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) - ret0, _ := ret[0].(*types2.QueryConnectionResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryConnection indicates an expected call of QueryConnection. -func (mr *MockIBCQuerierMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockIBCQuerier)(nil).QueryConnection), ctx, connectionID) -} - -// QueryNextSequenceReceive mocks base method. -func (m *MockIBCQuerier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockIBCQuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockIBCQuerier)(nil).QueryNextSequenceReceive), ctx) -} - -// QueryUnfinalizedRelayAcknowledgements mocks base method. -func (m *MockIBCQuerier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. -func (mr *MockIBCQuerierMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) -} - -// QueryUnfinalizedRelayPackets mocks base method. -func (m *MockIBCQuerier) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. -func (mr *MockIBCQuerierMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) -} - -// QueryUnreceivedAcknowledgements mocks base method. -func (m *MockIBCQuerier) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. -func (mr *MockIBCQuerierMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) -} - -// QueryUnreceivedPackets mocks base method. -func (m *MockIBCQuerier) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. -func (mr *MockIBCQuerierMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockIBCQuerier)(nil).QueryUnreceivedPackets), ctx, seqs) -} - -// MockICS02Querier is a mock of ICS02Querier interface. -type MockICS02Querier struct { - ctrl *gomock.Controller - recorder *MockICS02QuerierMockRecorder - isgomock struct{} -} - -// MockICS02QuerierMockRecorder is the mock recorder for MockICS02Querier. -type MockICS02QuerierMockRecorder struct { - mock *MockICS02Querier -} - -// NewMockICS02Querier creates a new mock instance. -func NewMockICS02Querier(ctrl *gomock.Controller) *MockICS02Querier { - mock := &MockICS02Querier{ctrl: ctrl} - mock.recorder = &MockICS02QuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockICS02Querier) EXPECT() *MockICS02QuerierMockRecorder { - return m.recorder -} - -// QueryClientConsensusState mocks base method. -func (m *MockICS02Querier) QueryClientConsensusState(ctx QueryContext, dstClientConsHeight exported.Height) (*types1.QueryConsensusStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientConsensusState", ctx, dstClientConsHeight) - ret0, _ := ret[0].(*types1.QueryConsensusStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientConsensusState indicates an expected call of QueryClientConsensusState. -func (mr *MockICS02QuerierMockRecorder) QueryClientConsensusState(ctx, dstClientConsHeight any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientConsensusState", reflect.TypeOf((*MockICS02Querier)(nil).QueryClientConsensusState), ctx, dstClientConsHeight) -} - -// QueryClientState mocks base method. -func (m *MockICS02Querier) QueryClientState(ctx QueryContext) (*types1.QueryClientStateResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryClientState", ctx) - ret0, _ := ret[0].(*types1.QueryClientStateResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryClientState indicates an expected call of QueryClientState. -func (mr *MockICS02QuerierMockRecorder) QueryClientState(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryClientState", reflect.TypeOf((*MockICS02Querier)(nil).QueryClientState), ctx) -} - -// MockICS03Querier is a mock of ICS03Querier interface. -type MockICS03Querier struct { - ctrl *gomock.Controller - recorder *MockICS03QuerierMockRecorder - isgomock struct{} -} - -// MockICS03QuerierMockRecorder is the mock recorder for MockICS03Querier. -type MockICS03QuerierMockRecorder struct { - mock *MockICS03Querier -} - -// NewMockICS03Querier creates a new mock instance. -func NewMockICS03Querier(ctrl *gomock.Controller) *MockICS03Querier { - mock := &MockICS03Querier{ctrl: ctrl} - mock.recorder = &MockICS03QuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockICS03Querier) EXPECT() *MockICS03QuerierMockRecorder { - return m.recorder -} - -// QueryConnection mocks base method. -func (m *MockICS03Querier) QueryConnection(ctx QueryContext, connectionID string) (*types2.QueryConnectionResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryConnection", ctx, connectionID) - ret0, _ := ret[0].(*types2.QueryConnectionResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryConnection indicates an expected call of QueryConnection. -func (mr *MockICS03QuerierMockRecorder) QueryConnection(ctx, connectionID any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConnection", reflect.TypeOf((*MockICS03Querier)(nil).QueryConnection), ctx, connectionID) -} - -// MockICS04Querier is a mock of ICS04Querier interface. -type MockICS04Querier struct { - ctrl *gomock.Controller - recorder *MockICS04QuerierMockRecorder - isgomock struct{} -} - -// MockICS04QuerierMockRecorder is the mock recorder for MockICS04Querier. -type MockICS04QuerierMockRecorder struct { - mock *MockICS04Querier -} - -// NewMockICS04Querier creates a new mock instance. -func NewMockICS04Querier(ctrl *gomock.Controller) *MockICS04Querier { - mock := &MockICS04Querier{ctrl: ctrl} - mock.recorder = &MockICS04QuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockICS04Querier) EXPECT() *MockICS04QuerierMockRecorder { - return m.recorder -} - -// QueryCanTransitionToFlushComplete mocks base method. -func (m *MockICS04Querier) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. -func (mr *MockICS04QuerierMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockICS04Querier)(nil).QueryCanTransitionToFlushComplete), ctx) -} - -// QueryChannel mocks base method. -func (m *MockICS04Querier) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannel", ctx) - ret0, _ := ret[0].(*types3.QueryChannelResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannel indicates an expected call of QueryChannel. -func (mr *MockICS04QuerierMockRecorder) QueryChannel(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannel), ctx) -} - -// QueryChannelUpgrade mocks base method. -func (m *MockICS04Querier) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. -func (mr *MockICS04QuerierMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannelUpgrade), ctx) -} - -// QueryChannelUpgradeError mocks base method. -func (m *MockICS04Querier) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. -func (mr *MockICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockICS04Querier)(nil).QueryChannelUpgradeError), ctx) -} - -// QueryNextSequenceReceive mocks base method. -func (m *MockICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockICS04Querier)(nil).QueryNextSequenceReceive), ctx) -} - -// QueryUnfinalizedRelayAcknowledgements mocks base method. -func (m *MockICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. -func (mr *MockICS04QuerierMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) -} - -// QueryUnfinalizedRelayPackets mocks base method. -func (m *MockICS04Querier) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. -func (mr *MockICS04QuerierMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) -} - -// QueryUnreceivedAcknowledgements mocks base method. -func (m *MockICS04Querier) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. -func (mr *MockICS04QuerierMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) -} - -// QueryUnreceivedPackets mocks base method. -func (m *MockICS04Querier) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. -func (mr *MockICS04QuerierMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockICS04Querier)(nil).QueryUnreceivedPackets), ctx, seqs) -} - -// MockICS20Querier is a mock of ICS20Querier interface. -type MockICS20Querier struct { - ctrl *gomock.Controller - recorder *MockICS20QuerierMockRecorder - isgomock struct{} -} - -// MockICS20QuerierMockRecorder is the mock recorder for MockICS20Querier. -type MockICS20QuerierMockRecorder struct { - mock *MockICS20Querier -} - -// NewMockICS20Querier creates a new mock instance. -func NewMockICS20Querier(ctrl *gomock.Controller) *MockICS20Querier { - mock := &MockICS20Querier{ctrl: ctrl} - mock.recorder = &MockICS20QuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockICS20Querier) EXPECT() *MockICS20QuerierMockRecorder { - return m.recorder -} - -// QueryBalance mocks base method. -func (m *MockICS20Querier) QueryBalance(ctx QueryContext, address types.AccAddress) (types.Coins, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryBalance", ctx, address) - ret0, _ := ret[0].(types.Coins) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryBalance indicates an expected call of QueryBalance. -func (mr *MockICS20QuerierMockRecorder) QueryBalance(ctx, address any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalance", reflect.TypeOf((*MockICS20Querier)(nil).QueryBalance), ctx, address) -} - -// QueryDenomTraces mocks base method. -func (m *MockICS20Querier) QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*types0.QueryDenomTracesResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryDenomTraces", ctx, offset, limit) - ret0, _ := ret[0].(*types0.QueryDenomTracesResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryDenomTraces indicates an expected call of QueryDenomTraces. -func (mr *MockICS20QuerierMockRecorder) QueryDenomTraces(ctx, offset, limit any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryDenomTraces", reflect.TypeOf((*MockICS20Querier)(nil).QueryDenomTraces), ctx, offset, limit) -} - -// MockLightClientICS04Querier is a mock of LightClientICS04Querier interface. -type MockLightClientICS04Querier struct { - ctrl *gomock.Controller - recorder *MockLightClientICS04QuerierMockRecorder - isgomock struct{} -} - -// MockLightClientICS04QuerierMockRecorder is the mock recorder for MockLightClientICS04Querier. -type MockLightClientICS04QuerierMockRecorder struct { - mock *MockLightClientICS04Querier -} - -// NewMockLightClientICS04Querier creates a new mock instance. -func NewMockLightClientICS04Querier(ctrl *gomock.Controller) *MockLightClientICS04Querier { - mock := &MockLightClientICS04Querier{ctrl: ctrl} - mock.recorder = &MockLightClientICS04QuerierMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockLightClientICS04Querier) EXPECT() *MockLightClientICS04QuerierMockRecorder { - return m.recorder -} - -// CheckRefreshRequired mocks base method. -func (m *MockLightClientICS04Querier) CheckRefreshRequired(ctx context.Context, counterparty ChainInfoICS02Querier) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckRefreshRequired", ctx, counterparty) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CheckRefreshRequired indicates an expected call of CheckRefreshRequired. -func (mr *MockLightClientICS04QuerierMockRecorder) CheckRefreshRequired(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRefreshRequired", reflect.TypeOf((*MockLightClientICS04Querier)(nil).CheckRefreshRequired), ctx, counterparty) -} - -// CreateInitialLightClientState mocks base method. -func (m *MockLightClientICS04Querier) CreateInitialLightClientState(ctx context.Context, height exported.Height) (exported.ClientState, exported.ConsensusState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInitialLightClientState", ctx, height) - ret0, _ := ret[0].(exported.ClientState) - ret1, _ := ret[1].(exported.ConsensusState) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// CreateInitialLightClientState indicates an expected call of CreateInitialLightClientState. -func (mr *MockLightClientICS04QuerierMockRecorder) CreateInitialLightClientState(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInitialLightClientState", reflect.TypeOf((*MockLightClientICS04Querier)(nil).CreateInitialLightClientState), ctx, height) -} - -// GetLatestFinalizedHeader mocks base method. -func (m *MockLightClientICS04Querier) GetLatestFinalizedHeader(ctx context.Context) (Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLatestFinalizedHeader", ctx) - ret0, _ := ret[0].(Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLatestFinalizedHeader indicates an expected call of GetLatestFinalizedHeader. -func (mr *MockLightClientICS04QuerierMockRecorder) GetLatestFinalizedHeader(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestFinalizedHeader", reflect.TypeOf((*MockLightClientICS04Querier)(nil).GetLatestFinalizedHeader), ctx) -} - -// QueryCanTransitionToFlushComplete mocks base method. -func (m *MockLightClientICS04Querier) QueryCanTransitionToFlushComplete(ctx QueryContext) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryCanTransitionToFlushComplete", ctx) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryCanTransitionToFlushComplete indicates an expected call of QueryCanTransitionToFlushComplete. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryCanTransitionToFlushComplete(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryCanTransitionToFlushComplete", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryCanTransitionToFlushComplete), ctx) -} - -// QueryChannel mocks base method. -func (m *MockLightClientICS04Querier) QueryChannel(ctx QueryContext) (*types3.QueryChannelResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannel", ctx) - ret0, _ := ret[0].(*types3.QueryChannelResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannel indicates an expected call of QueryChannel. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannel(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannel", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannel), ctx) -} - -// QueryChannelUpgrade mocks base method. -func (m *MockLightClientICS04Querier) QueryChannelUpgrade(ctx QueryContext) (*types3.QueryUpgradeResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgrade", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgrade indicates an expected call of QueryChannelUpgrade. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannelUpgrade(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgrade", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannelUpgrade), ctx) -} - -// QueryChannelUpgradeError mocks base method. -func (m *MockLightClientICS04Querier) QueryChannelUpgradeError(ctx QueryContext) (*types3.QueryUpgradeErrorResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryChannelUpgradeError", ctx) - ret0, _ := ret[0].(*types3.QueryUpgradeErrorResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryChannelUpgradeError indicates an expected call of QueryChannelUpgradeError. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryChannelUpgradeError(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryChannelUpgradeError", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryChannelUpgradeError), ctx) -} - -// QueryNextSequenceReceive mocks base method. -func (m *MockLightClientICS04Querier) QueryNextSequenceReceive(ctx QueryContext) (*types3.QueryNextSequenceReceiveResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryNextSequenceReceive", ctx) - ret0, _ := ret[0].(*types3.QueryNextSequenceReceiveResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryNextSequenceReceive indicates an expected call of QueryNextSequenceReceive. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryNextSequenceReceive(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNextSequenceReceive", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryNextSequenceReceive), ctx) -} - -// QueryUnfinalizedRelayAcknowledgements mocks base method. -func (m *MockLightClientICS04Querier) QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayAcknowledgements", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayAcknowledgements indicates an expected call of QueryUnfinalizedRelayAcknowledgements. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnfinalizedRelayAcknowledgements(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayAcknowledgements", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnfinalizedRelayAcknowledgements), ctx, counterparty) -} - -// QueryUnfinalizedRelayPackets mocks base method. -func (m *MockLightClientICS04Querier) QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnfinalizedRelayPackets", ctx, counterparty) - ret0, _ := ret[0].(PacketInfoList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnfinalizedRelayPackets indicates an expected call of QueryUnfinalizedRelayPackets. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnfinalizedRelayPackets(ctx, counterparty any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnfinalizedRelayPackets", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnfinalizedRelayPackets), ctx, counterparty) -} - -// QueryUnreceivedAcknowledgements mocks base method. -func (m *MockLightClientICS04Querier) QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedAcknowledgements", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedAcknowledgements indicates an expected call of QueryUnreceivedAcknowledgements. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnreceivedAcknowledgements(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedAcknowledgements", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnreceivedAcknowledgements), ctx, seqs) -} - -// QueryUnreceivedPackets mocks base method. -func (m *MockLightClientICS04Querier) QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUnreceivedPackets", ctx, seqs) - ret0, _ := ret[0].([]uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// QueryUnreceivedPackets indicates an expected call of QueryUnreceivedPackets. -func (mr *MockLightClientICS04QuerierMockRecorder) QueryUnreceivedPackets(ctx, seqs any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUnreceivedPackets", reflect.TypeOf((*MockLightClientICS04Querier)(nil).QueryUnreceivedPackets), ctx, seqs) -} - -// SetupHeadersForUpdate mocks base method. -func (m *MockLightClientICS04Querier) SetupHeadersForUpdate(ctx context.Context, counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetupHeadersForUpdate", ctx, counterparty, latestFinalizedHeader) - ret0, _ := ret[0].([]Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetupHeadersForUpdate indicates an expected call of SetupHeadersForUpdate. -func (mr *MockLightClientICS04QuerierMockRecorder) SetupHeadersForUpdate(ctx, counterparty, latestFinalizedHeader any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupHeadersForUpdate", reflect.TypeOf((*MockLightClientICS04Querier)(nil).SetupHeadersForUpdate), ctx, counterparty, latestFinalizedHeader) -} - -// MockQueryContext is a mock of QueryContext interface. -type MockQueryContext struct { - ctrl *gomock.Controller - recorder *MockQueryContextMockRecorder - isgomock struct{} -} - -// MockQueryContextMockRecorder is the mock recorder for MockQueryContext. -type MockQueryContextMockRecorder struct { - mock *MockQueryContext -} - -// NewMockQueryContext creates a new mock instance. -func NewMockQueryContext(ctrl *gomock.Controller) *MockQueryContext { - mock := &MockQueryContext{ctrl: ctrl} - mock.recorder = &MockQueryContextMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockQueryContext) EXPECT() *MockQueryContextMockRecorder { - return m.recorder -} - -// Context mocks base method. -func (m *MockQueryContext) Context() context.Context { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Context") - ret0, _ := ret[0].(context.Context) - return ret0 -} - -// Context indicates an expected call of Context. -func (mr *MockQueryContextMockRecorder) Context() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockQueryContext)(nil).Context)) -} - -// Height mocks base method. -func (m *MockQueryContext) Height() exported.Height { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Height") - ret0, _ := ret[0].(exported.Height) - return ret0 -} - -// Height indicates an expected call of Height. -func (mr *MockQueryContextMockRecorder) Height() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockQueryContext)(nil).Height)) -} From 7c19a56d0c3081d1d39d67fc61d895efc3c012a3 Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 31 Mar 2025 09:35:51 +0000 Subject: [PATCH 12/14] support case of timeout at latest but not at finalized Signed-off-by: Daisuke Kanda --- core/naive-strategy.go | 70 ++++++++++++++++++++++++++++++++---------- core/service_test.go | 32 ++++++++++++++++++- 2 files changed, 85 insertions(+), 17 deletions(-) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index bcd00cce..39ae9824 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -206,34 +206,69 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro var ( srcPackets PacketInfoList dstPackets PacketInfoList - srcHeight ibcexported.Height - srcTimestamp uint64 - dstHeight ibcexported.Height - dstTimestamp uint64 + srcLatestHeight ibcexported.Height + srcLatestTimestamp uint64 + srcLatestFinalizedHeight ibcexported.Height + srcLatestFinalizedTimestamp uint64 + dstLatestHeight ibcexported.Height + dstLatestTimestamp uint64 + dstLatestFinalizedHeight ibcexported.Height + dstLatestFinalizedTimestamp uint64 ) if 0 < len(rp.Src) { - dstHeight = sh.GetLatestFinalizedHeader(dst.ChainID()).GetHeight() - timestamp, err := dst.Timestamp(context.TODO(), dstHeight) - if err != nil { + if h, err := dst.LatestHeight(context.TODO()); err != nil { + logger.Error("fail to get dst.LatestHeight", err) + return nil, err + } else { + dstLatestHeight = h + } + + if t, err := dst.Timestamp(context.TODO(), dstLatestHeight); err != nil { + logger.Error("fail to get dst.Timestamp", err) + return nil, err + } else { + dstLatestTimestamp = uint64(t.UnixNano()) + } + + dstLatestFinalizedHeight = sh.GetLatestFinalizedHeader(dst.ChainID()).GetHeight() + if t, err := dst.Timestamp(context.TODO(), dstLatestFinalizedHeight); err != nil { logger.Error("fail to get dst.Timestamp", err) return nil, err + } else { + dstLatestFinalizedTimestamp = uint64(t.UnixNano()) } - dstTimestamp = uint64(timestamp.UnixNano()) } if 0 < len(rp.Dst) { - srcHeight = sh.GetLatestFinalizedHeader(src.ChainID()).GetHeight() - timestamp, err := src.Timestamp(context.TODO(), srcHeight) - if err != nil { + if h, err := src.LatestHeight(context.TODO()); err != nil { + logger.Error("fail to get src.LatestHeight", err) + return nil, err + } else { + srcLatestHeight = h + } + if t, err := src.Timestamp(context.TODO(), srcLatestHeight); err != nil { logger.Error("fail to get src.Timestamp", err) return nil, err + } else { + srcLatestTimestamp = uint64(t.UnixNano()) } - srcTimestamp = uint64(timestamp.UnixNano()) + + srcLatestFinalizedHeight = sh.GetLatestFinalizedHeader(src.ChainID()).GetHeight() + if t, err := src.Timestamp(context.TODO(), srcLatestFinalizedHeight); err != nil { + logger.Error("fail to get src.Timestamp", err) + return nil, err + } else { + srcLatestFinalizedTimestamp = uint64(t.UnixNano()) + } + } + + isTimeout := func(p *PacketInfo, height ibcexported.Height, timestamp uint64) (bool) { + return (!p.TimeoutHeight.IsZero() && p.TimeoutHeight.LTE(height)) || + (p.TimeoutTimestamp != 0 && p.TimeoutTimestamp <= timestamp) } for i, p := range rp.Src { - if (!p.TimeoutHeight.IsZero() && p.TimeoutHeight.LTE(dstHeight)) || - (p.TimeoutTimestamp != 0 && p.TimeoutTimestamp <= dstTimestamp) { + if isTimeout(p, dstLatestFinalizedHeight, dstLatestFinalizedTimestamp) { p.Sort = "timeout" if src.Path().GetOrder() == chantypes.ORDERED { if i == 0 { @@ -243,13 +278,14 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro } else { dstPackets = append(dstPackets, p) } + } else if isTimeout(p, dstLatestHeight, dstLatestTimestamp) { + break } else { srcPackets = append(srcPackets, p) } } for i, p := range rp.Dst { - if (!p.TimeoutHeight.IsZero() && p.TimeoutHeight.LTE(srcHeight)) || - (p.TimeoutTimestamp != 0 && p.TimeoutTimestamp <= srcTimestamp) { + if (isTimeout(p, srcLatestFinalizedHeight, srcLatestFinalizedTimestamp)) { p.Sort = "timeout" if dst.Path().GetOrder() == chantypes.ORDERED { if i == 0 { @@ -259,6 +295,8 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro } else { srcPackets = append(srcPackets, p) } + } else if (isTimeout(p, srcLatestHeight, srcLatestTimestamp)) { + break } else { dstPackets = append(dstPackets, p) } diff --git a/core/service_test.go b/core/service_test.go index 3d35386b..fb6f5517 100644 --- a/core/service_test.go +++ b/core/service_test.go @@ -222,15 +222,45 @@ func TestServe(t *testing.T) { []string{ }, []string{ }, }, + "@not timeout(at border height)": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 101), + }, + []string{ }, + []string{ + "MsgUpdateClient(dstClient)", + "MsgRecvPacket(1)", + }, + }, "timeout": { "ORDERED", 1, []*core.PacketInfo{ - newPacketInfo(1, 9), + newPacketInfo(1, 90), }, []string{ "MsgUpdateClient(srcClient)", "MsgTimeout(1)" }, []string{ }, }, + "timeout at latest block but not at finalized block(at lower border)": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 91), + }, + []string{ }, + []string{ }, + }, + "timeout at latest block but not at finalized block(at heigher border)": { + "ORDERED", + 1, + []*core.PacketInfo{ + newPacketInfo(1, 100), + }, + []string{ }, + []string{ }, + }, "only packets precede timeout packet": { "ORDERED", 1, From cced950cd2669f6c6230eac13b35d936552ea6fb Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 31 Mar 2025 09:43:45 +0000 Subject: [PATCH 13/14] refactoring. rename Sort to Process or Timeout Signed-off-by: Daisuke Kanda --- cmd/tx.go | 2 +- core/naive-strategy.go | 12 +++++++----- core/service.go | 4 ++-- core/service_test.go | 8 ++++---- core/strategies.go | 4 ++-- core/types.go | 2 +- 6 files changed, 17 insertions(+), 15 deletions(-) diff --git a/cmd/tx.go b/cmd/tx.go index af42e28f..e80762bd 100644 --- a/cmd/tx.go +++ b/cmd/tx.go @@ -457,7 +457,7 @@ func relayMsgsCmd(ctx *config.Context) *cobra.Command { return err } - sp, err = st.SortUnrelayedPackets(cmd.Context(), c[src], c[dst], sh, sp) + sp, err = st.ProcessTimeoutPackets(cmd.Context(), c[src], c[dst], sh, sp) if err != nil { return err } diff --git a/core/naive-strategy.go b/core/naive-strategy.go index 39ae9824..dd0e5781 100644 --- a/core/naive-strategy.go +++ b/core/naive-strategy.go @@ -201,7 +201,7 @@ func (st *NaiveStrategy) UnrelayedPackets(ctx context.Context, src, dst *Provabl }, nil } -func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) { +func (st *NaiveStrategy) ProcessTimeoutPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) { logger := GetChannelPairLogger(src, dst) var ( srcPackets PacketInfoList @@ -269,7 +269,7 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro for i, p := range rp.Src { if isTimeout(p, dstLatestFinalizedHeight, dstLatestFinalizedTimestamp) { - p.Sort = "timeout" + p.TimedOut = true if src.Path().GetOrder() == chantypes.ORDERED { if i == 0 { dstPackets = append(dstPackets, p) @@ -281,12 +281,13 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro } else if isTimeout(p, dstLatestHeight, dstLatestTimestamp) { break } else { + p.TimedOut = false srcPackets = append(srcPackets, p) } } for i, p := range rp.Dst { if (isTimeout(p, srcLatestFinalizedHeight, srcLatestFinalizedTimestamp)) { - p.Sort = "timeout" + p.TimedOut = true if dst.Path().GetOrder() == chantypes.ORDERED { if i == 0 { srcPackets = append(srcPackets, p) @@ -298,6 +299,7 @@ func (st *NaiveStrategy) SortUnrelayedPackets(ctx context.Context, src, dst *Pro } else if (isTimeout(p, srcLatestHeight, srcLatestTimestamp)) { break } else { + p.TimedOut = false dstPackets = append(dstPackets, p) } } @@ -504,7 +506,7 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoLi var nextSequenceRecv uint64 if chain.Path().GetOrder() == chantypes.ORDERED { for _, p := range packets { - if p.Sort == "timeout" { + if p.TimedOut { res, err := chain.QueryNextSequenceReceive(ctx) if err != nil { logger.Error("failed to QueryNextSequenceReceive", err, @@ -524,7 +526,7 @@ func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoLi var msgs []sdk.Msg for _, p := range packets { var msg sdk.Msg - if p.Sort == "timeout" { + if p.TimedOut { // make path of original packet's destination port and channel var path string var commitment []byte diff --git a/core/service.go b/core/service.go index 7028573a..a04df28e 100644 --- a/core/service.go +++ b/core/service.go @@ -119,9 +119,9 @@ func (srv *RelayService) Serve(ctx context.Context) error { return err } - pseqs2, err := srv.st.SortUnrelayedPackets(ctx, srv.src, srv.dst, srv.sh, pseqs) + pseqs2, err := srv.st.ProcessTimeoutPackets(ctx, srv.src, srv.dst, srv.sh, pseqs) if err != nil { - logger.Error("failed to sort unrelayed packets", err) + logger.Error("failed to process timeout packets", err) return err } diff --git a/core/service_test.go b/core/service_test.go index fb6f5517..ce62e06d 100644 --- a/core/service_test.go +++ b/core/service_test.go @@ -28,7 +28,7 @@ type NaiveStrategyWrap struct { Inner *core.NaiveStrategy UnrelayedPacketsOut *core.RelayPackets - SortUnrelayedPacketsOut *core.RelayPackets + ProcessTimeoutPacketsOut *core.RelayPackets UnrelayedAcknowledgementsOut *core.RelayPackets RelayPacketsOut *core.RelayMsgs RelayAcknowledgementsOut *core.RelayMsgs @@ -44,9 +44,9 @@ func (s *NaiveStrategyWrap) UnrelayedPackets(ctx context.Context, src, dst *core return ret, err } -func (s *NaiveStrategyWrap) SortUnrelayedPackets(ctx context.Context, src, dst *core.ProvableChain, sh core.SyncHeaders, rp *core.RelayPackets) (*core.RelayPackets, error) { - ret, err := s.Inner.SortUnrelayedPackets(ctx, src, dst, sh, rp) - s.SortUnrelayedPacketsOut = ret +func (s *NaiveStrategyWrap) ProcessTimeoutPackets(ctx context.Context, src, dst *core.ProvableChain, sh core.SyncHeaders, rp *core.RelayPackets) (*core.RelayPackets, error) { + ret, err := s.Inner.ProcessTimeoutPackets(ctx, src, dst, sh, rp) + s.ProcessTimeoutPacketsOut = ret return ret, err } diff --git a/core/strategies.go b/core/strategies.go index e4e9f869..cbd5195a 100644 --- a/core/strategies.go +++ b/core/strategies.go @@ -24,8 +24,8 @@ type StrategyI interface { // `includeRelayedButUnfinalized` decides if the result includes packets of which acknowledgePacket has been executed but not finalized UnrelayedAcknowledgements(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error) - // SortUnrelayedPackets sorts given RelayPackets and returns sorted RelayPackets. Note that input Packet object may be modified. - SortUnrelayedPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) + // ProcessTimeoutPackets process timeout packets in given RelayPackets and returns sorted RelayPackets. Note that input Packet object may be modified. + ProcessTimeoutPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error) // RelayAcknowledgements executes AcknowledgePacket to the packets contained in `rp` on both chains (`src` and `dst`). RelayAcknowledgements(ctx context.Context, src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*RelayMsgs, error) diff --git a/core/types.go b/core/types.go index 5cedbe54..e24ae5ff 100644 --- a/core/types.go +++ b/core/types.go @@ -13,7 +13,7 @@ type PacketInfo struct { chantypes.Packet Acknowledgement []byte `json:"acknowledgement"` EventHeight clienttypes.Height `json:"event_height"` - Sort string `json:"sort"` + TimedOut bool `json:"timed_out"` } // PacketInfoList represents a list of PacketInfo that is sorted in the order in which From 80f0dd1460ae949752a8becb7015b19b6672314c Mon Sep 17 00:00:00 2001 From: Daisuke Kanda Date: Mon, 14 Apr 2025 08:26:32 +0000 Subject: [PATCH 14/14] update ibc-mock-client Signed-off-by: Daisuke Kanda --- go.mod | 6 +++--- go.sum | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/go.mod b/go.mod index 52b1d523..221bde1d 100644 --- a/go.mod +++ b/go.mod @@ -16,17 +16,19 @@ require ( github.com/cosmos/gogoproto v1.4.11 github.com/cosmos/ibc-go/modules/capability v1.0.0 github.com/cosmos/ibc-go/v8 v8.2.1 - github.com/datachainlab/ibc-mock-client v0.4.2 + github.com/datachainlab/ibc-mock-client v0.4.3 github.com/prometheus/client_golang v1.20.5 github.com/spf13/cobra v1.8.0 github.com/spf13/pflag v1.0.5 github.com/spf13/viper v1.18.2 + github.com/stretchr/testify v1.10.0 go.opentelemetry.io/otel v1.33.0 go.opentelemetry.io/otel/exporters/prometheus v0.55.0 go.opentelemetry.io/otel/metric v1.33.0 go.opentelemetry.io/otel/sdk/metric v1.33.0 go.uber.org/mock v0.5.0 golang.org/x/sync v0.10.0 + golang.org/x/sys v0.28.0 google.golang.org/grpc v1.62.0 gopkg.in/yaml.v2 v2.4.0 ) @@ -162,7 +164,6 @@ require ( github.com/sourcegraph/conc v0.3.0 // indirect github.com/spf13/afero v1.11.0 // indirect github.com/spf13/cast v1.6.0 // indirect - github.com/stretchr/testify v1.10.0 // indirect github.com/subosito/gotenv v1.6.0 // indirect github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect github.com/tendermint/go-amino v0.16.0 // indirect @@ -182,7 +183,6 @@ require ( golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 // indirect golang.org/x/net v0.32.0 // indirect golang.org/x/oauth2 v0.24.0 // indirect - golang.org/x/sys v0.28.0 // indirect golang.org/x/term v0.27.0 // indirect golang.org/x/text v0.21.0 // indirect golang.org/x/time v0.5.0 // indirect diff --git a/go.sum b/go.sum index c4f2cedf..398a735d 100644 --- a/go.sum +++ b/go.sum @@ -377,8 +377,8 @@ github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7Do github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/danieljoos/wincred v1.1.2 h1:QLdCxFs1/Yl4zduvBdcHB8goaYk9RARS2SgLLRuAyr0= github.com/danieljoos/wincred v1.1.2/go.mod h1:GijpziifJoIBfYh+S7BbkdUTU4LfM+QnGqR5Vl2tAx0= -github.com/datachainlab/ibc-mock-client v0.4.2 h1:0BbQFwLUUbKknCsUO6m80VogRbJop5kA0u9/3Hma9n0= -github.com/datachainlab/ibc-mock-client v0.4.2/go.mod h1:Fn37FzeevLp5gmla4TSoDY56Jm2tBcqz+p0lIyRCOsg= +github.com/datachainlab/ibc-mock-client v0.4.3 h1:vFl8P4lx0aAgvnZIMfmwhDcj8atps1aP+sthzKdVNo8= +github.com/datachainlab/ibc-mock-client v0.4.3/go.mod h1:Fn37FzeevLp5gmla4TSoDY56Jm2tBcqz+p0lIyRCOsg= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=