core

type Chain interface {
	// GetAddress returns the address of relayer
	GetAddress() (sdk.AccAddress, error)

	// Codec returns the codec
	Codec() codec.ProtoCodecMarshaler

	// Path returns the path
	Path() *PathEnd

	// Init initializes the chain
	Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error

	// SetRelayInfo sets source's path and counterparty's info to the chain
	SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error

	// SetupForRelay performs chain-specific setup before starting the relay
	SetupForRelay(ctx context.Context) error

	// SendMsgs sends msgs to the chain and waits for them to be included in blocks.
	// This function returns err=nil only if all the msgs executed successfully at the blocks.
	// It should be noted that the block is not finalized at that point and can be reverted afterwards.
	SendMsgs(msgs []sdk.Msg) ([]MsgID, error)

	// GetMsgResult returns the execution result of `sdk.Msg` specified by `MsgID`
	// If the msg is not included in any block, this function waits for inclusion.
	GetMsgResult(id MsgID) (MsgResult, error)

	// RegisterMsgEventListener registers a given EventListener to the chain
	RegisterMsgEventListener(MsgEventListener)

	ChainInfo
	IBCQuerier
	ICS20Querier
}

type ChainConfig interface {
	proto.Message
	Build() (Chain, error)
	Validate() error
}

type ChainInfo interface {
	// ChainID returns ID of the chain
	ChainID() string

	// LatestHeight returns the latest height of the chain
	//
	// NOTE: The returned height does not have to be finalized.
	// If a finalized height/header is required, the `Prover`'s `GetLatestFinalizedHeader` function should be called instead.
	LatestHeight() (ibcexported.Height, error)

	// Timestamp returns the block timestamp
	Timestamp(ibcexported.Height) (time.Time, error)

	// AverageBlockTime returns the average time required for each new block to be committed
	AverageBlockTime() time.Duration
}

type ChainInfoICS02Querier interface {
	ChainInfo
	ICS02Querier
}

type ChainInfoLightClient interface {
	ChainInfo
	LightClient
}

type ChainLightClient interface {
	Chain
	LightClient
}

type ChainProverConfig struct {
	Chain  json.RawMessage `json:"chain" yaml:"chain"` // NOTE: it's any type as json format
	Prover json.RawMessage `json:"prover" yaml:"prover"`
	// contains filtered or unexported fields
}

type ConfigI interface {
	UpdateConfigID(pathName string, chainID string, configID ConfigIDType, id string) error
}

type ConfigIDType string

type EventAcknowledgePacket struct {
	Sequence         uint64
	SrcPort          string
	SrcChannel       string
	TimeoutHeight    clienttypes.Height
	TimeoutTimestamp time.Time
	// contains filtered or unexported fields
}

type EventGenerateChannelIdentifier struct {
	ID string
	// contains filtered or unexported fields
}

type EventGenerateClientIdentifier struct {
	ID string
	// contains filtered or unexported fields
}

type EventGenerateConnectionIdentifier struct {
	ID string
	// contains filtered or unexported fields
}

type EventRecvPacket struct {
	Sequence         uint64
	DstPort          string
	DstChannel       string
	TimeoutHeight    clienttypes.Height
	TimeoutTimestamp time.Time
	Data             []byte
	// contains filtered or unexported fields
}

type EventSendPacket struct {
	Sequence         uint64
	SrcPort          string
	SrcChannel       string
	TimeoutHeight    clienttypes.Height
	TimeoutTimestamp time.Time
	Data             []byte
	// contains filtered or unexported fields
}

type EventUnknown struct {
	Value any
	// contains filtered or unexported fields
}

type EventWriteAcknowledgement struct {
	Sequence        uint64
	DstPort         string
	DstChannel      string
	Acknowledgement []byte
	// contains filtered or unexported fields
}

type FinalityAware interface {
	// GetLatestFinalizedHeader returns the latest finalized header on this chain
	// The returned header is expected to be the latest one of headers that can be verified by the light client
	GetLatestFinalizedHeader() (latestFinalizedHeader Header, err error)
}

type FinalityAwareChain interface {
	FinalityAware
	Chain
}

type Header interface {
	exported.ClientMessage
	GetHeight() exported.Height
}

type IBCQuerier interface {
	ICS02Querier
	ICS03Querier
	ICS04Querier
}

type ICS02Querier interface {
	// QueryClientConsensusState retrevies the latest consensus state for a client in state at a given height
	QueryClientConsensusState(ctx QueryContext, dstClientConsHeight ibcexported.Height) (*clienttypes.QueryConsensusStateResponse, error)

	// QueryClientState returns the client state of dst chain
	// height represents the height of dst chain
	QueryClientState(ctx QueryContext) (*clienttypes.QueryClientStateResponse, error)
}

type ICS03Querier interface {
	// QueryConnection returns the remote end of a given connection
	QueryConnection(ctx QueryContext) (*conntypes.QueryConnectionResponse, error)
}

type ICS04Querier interface {
	// QueryChannel returns the channel associated with a channelID
	QueryChannel(ctx QueryContext) (chanRes *chantypes.QueryChannelResponse, err error)

	// QueryUnreceivedPackets returns a list of unrelayed packet commitments
	QueryUnreceivedPackets(ctx QueryContext, seqs []uint64) ([]uint64, error)

	// QueryUnfinalizedRelayedPackets returns packets and heights that are sent but not received at the latest finalized block on the counterparty chain
	QueryUnfinalizedRelayPackets(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error)

	// QueryUnreceivedAcknowledgements returns a list of unrelayed packet acks
	QueryUnreceivedAcknowledgements(ctx QueryContext, seqs []uint64) ([]uint64, error)

	// QueryUnfinalizedRelayedAcknowledgements returns acks and heights that are sent but not received at the latest finalized block on the counterpartychain
	QueryUnfinalizedRelayAcknowledgements(ctx QueryContext, counterparty LightClientICS04Querier) (PacketInfoList, error)
}

type ICS20Querier interface {
	// QueryBalance returns the amount of coins in the relayer account
	QueryBalance(ctx QueryContext, address sdk.AccAddress) (sdk.Coins, error)

	// QueryDenomTraces returns all the denom traces from a given chain
	QueryDenomTraces(ctx QueryContext, offset, limit uint64) (*transfertypes.QueryDenomTracesResponse, error)
}

type LightClient interface {
	FinalityAware

	// 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(height exported.Height) (exported.ClientState, exported.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: [<intermediate headers>..., <update header>]
	// if the header slice's length == 0 and err == nil, the relayer should skips the update-client
	SetupHeadersForUpdate(counterparty FinalityAwareChain, latestFinalizedHeader Header) ([]Header, error)

	// CheckRefreshRequired returns if the on-chain light client needs to be updated.
	// For example, this requirement arises due to the trusting period mechanism.
	CheckRefreshRequired(counterparty ChainInfoICS02Querier) (bool, error)
}

type LightClientICS04Querier interface {
	LightClient
	ICS04Querier
}

type MsgEventListener interface {
	// OnSentMsg is a callback functoin that is called when a msg send to the chain
	OnSentMsg(msgs []sdk.Msg) error
}

type MsgEventLog interface {
	// contains filtered or unexported methods
}

type MsgID interface {
	proto.Message
	Is_MsgID()
}

type MsgResult interface {
	// BlockHeight returns the height that the message is included.
	BlockHeight() clienttypes.Height

	// Status returns true if the execution of the message is successful.
	// If it fails, this function returns false with the second return value that provides additional information.
	Status() (bool, string)

	// Events returns events emitted by the message.
	Events() []MsgEventLog
}

type NaiveStrategy struct {
	Ordered      bool
	MaxTxSize    uint64 // maximum permitted size of the msgs in a bundled relay transaction
	MaxMsgLength uint64 // maximum amount of messages in a bundled relay transaction
	// contains filtered or unexported fields
}

type OptimizeRelay struct {
	// contains filtered or unexported fields
}

type PacketInfo struct {
	chantypes.Packet
	Acknowledgement []byte             `json:"acknowledgement"`
	EventHeight     clienttypes.Height `json:"event_height"`
}

type PacketInfoList []*PacketInfo

type Path struct {
	Src      *PathEnd     `yaml:"src" json:"src"`
	Dst      *PathEnd     `yaml:"dst" json:"dst"`
	Strategy *StrategyCfg `yaml:"strategy" json:"strategy"`
}

type PathEnd struct {
	ChainID      string `yaml:"chain-id,omitempty" json:"chain-id,omitempty"`
	ClientID     string `yaml:"client-id,omitempty" json:"client-id,omitempty"`
	ConnectionID string `yaml:"connection-id,omitempty" json:"connection-id,omitempty"`
	ChannelID    string `yaml:"channel-id,omitempty" json:"channel-id,omitempty"`
	PortID       string `yaml:"port-id,omitempty" json:"port-id,omitempty"`
	Order        string `yaml:"order,omitempty" json:"order,omitempty"`
	Version      string `yaml:"version,omitempty" json:"version,omitempty"`
}

type PathStatus struct {
	Chains     bool `yaml:"chains" json:"chains"`
	Clients    bool `yaml:"clients" json:"clients"`
	Connection bool `yaml:"connection" json:"connection"`
	Channel    bool `yaml:"channel" json:"channel"`
}

type PathWithStatus struct {
	Path   *Path      `yaml:"path" json:"chains"`
	Status PathStatus `yaml:"status" json:"status"`
}

type Paths map[string]*Path

type ProvableChain struct {
	Chain
	Prover
}

type Prover interface {
	// Init initializes the chain
	Init(homePath string, timeout time.Duration, codec codec.ProtoCodecMarshaler, debug bool) error

	// SetRelayInfo sets source's path and counterparty's info to the chain
	SetRelayInfo(path *PathEnd, counterparty *ProvableChain, counterpartyPath *PathEnd) error

	// SetupForRelay performs chain-specific setup before starting the relay
	SetupForRelay(ctx context.Context) error

	LightClient
	StateProver
}

type ProverConfig interface {
	proto.Message
	Build(Chain) (Prover, error)
	Validate() error
}

type QueryContext interface {
	// Context returns `context.Context“
	Context() context.Context

	// Height returns a height of the target chain for querying a state
	Height() ibcexported.Height
}

type RelayMsgs struct {
	Src          []sdk.Msg `json:"src"`
	Dst          []sdk.Msg `json:"dst"`
	MaxTxSize    uint64    `json:"max_tx_size"`    // maximum permitted size of the msgs in a bundled relay transaction
	MaxMsgLength uint64    `json:"max_msg_length"` // maximum amount of messages in a bundled relay transaction

	Last      bool `json:"last"`
	Succeeded bool `json:"success"`

	SrcMsgIDs []MsgID `json:"src_msg_ids"`
	DstMsgIDs []MsgID `json:"dst_msg_ids"`
}

type RelayPackets struct {
	Src PacketInfoList `json:"src"`
	Dst PacketInfoList `json:"dst"`
}

type RelayService struct {
	// contains filtered or unexported fields
}

type StateProver interface {
	// ProveState returns a proof of an IBC state specified by `path` and `value`
	ProveState(ctx QueryContext, path string, value []byte) (proof []byte, proofHeight clienttypes.Height, err error)

	// 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)
}

type StrategyCfg struct {
	Type string `json:"type" yaml:"type"`

	// If set, executions of acknowledgePacket are always skipped on the src chain.
	// Also `UnrelayedAcknowledgements` returns zero packets for the src chain.
	SrcNoack bool `json:"src-noack" yaml:"src-noack"`

	// If set, executions of acknowledgePacket are always skipped on the dst chain
	// Also `UnrelayedAcknowledgements` returns zero packets for the dst chain.
	DstNoack bool `json:"dst-noack" yaml:"dst-noack"`
}

type StrategyI interface {
	// GetType returns the type of the strategy
	GetType() string

	// SetupRelay performs chain-specific setup for `src` and `dst` before starting the relay
	SetupRelay(ctx context.Context, src, dst *ProvableChain) error

	// UnrelayedPackets returns packets to execute RecvPacket to on `src` and `dst`.
	// `includeRelayedButUnfinalized` decides if the result includes packets of which recvPacket has been executed but not finalized
	UnrelayedPackets(src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error)

	// RelayPackets executes RecvPacket to the packets contained in `rp` on both chains (`src` and `dst`).
	RelayPackets(src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteRelaySrc, doExecuteRelayDst bool) (*RelayMsgs, error)

	// UnrelayedAcknowledgements returns packets to execute AcknowledgePacket to on `src` and `dst`.
	// `includeRelayedButUnfinalized` decides if the result includes packets of which acknowledgePacket has been executed but not finalized
	UnrelayedAcknowledgements(src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error)

	// RelayAcknowledgements executes AcknowledgePacket to the packets contained in `rp` on both chains (`src` and `dst`).
	RelayAcknowledgements(src, dst *ProvableChain, rp *RelayPackets, sh SyncHeaders, doExecuteAckSrc, doExecuteAckDst bool) (*RelayMsgs, error)

	// UpdateClients executes UpdateClient only if needed
	UpdateClients(src, dst *ProvableChain, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst bool, sh SyncHeaders, doRefresh bool) (*RelayMsgs, error)

	// Send executes submission of msgs to src/dst chains
	Send(src, dst Chain, msgs *RelayMsgs)
}

type SyncHeaders interface {
	// Updates updates the headers on both chains
	Updates(src, dst ChainInfoLightClient) error

	// GetLatestFinalizedHeader returns the latest finalized header of the chain
	GetLatestFinalizedHeader(chainID string) Header

	// GetQueryContext builds a query context based on the latest finalized header
	GetQueryContext(chainID string) QueryContext

	// SetupHeadersForUpdate returns `src` chain's headers needed to update the client on `dst` chain
	SetupHeadersForUpdate(src, dst ChainLightClient) ([]Header, error)

	// SetupBothHeadersForUpdate returns both `src` and `dst` chain's headers needed to update the clients on each chain
	SetupBothHeadersForUpdate(src, dst ChainLightClient) (srcHeaders []Header, dstHeaders []Header, err error)
}