fix: find proofContext change heights from last client state to lates…

…t block

relayer/chains/cosmos/query.go

@@ -1191,3 +1191,7 @@ func (ap *CosmosProvider) QueryMissingPacketReceipts(ctx context.Context, latest
 func (ap *CosmosProvider) QueryNextSeqSend(ctx context.Context, height int64, channelid, portid string) (seq uint64, err error) {
 	panic("QueryNextSeqSend not implemented")
 }
+
+func (ap *CosmosProvider) QueryProofContextChangeHeights(ctx context.Context, counterpartyClientHeight uint64, height uint64) ([]uint64, error) {
+	panic("QueryProofContextChangeHeights not implemented")
+}

relayer/chains/icon/client.go

@@ -64,6 +64,7 @@ type IClient interface {
 	GetLastBlock() (*types.Block, error)
 	GetBlockHeaderByHeight(height int64) (*types.BlockHeader, error)
 	GetValidatorsByHash(hash common.HexHash) ([]common.Address, error)
+	GetPrepTerm() (*types.PrepTerm, error)
 }
 
 type Client struct {
@@ -622,6 +623,25 @@ func (c *Client) EstimateStep(param *types.TransactionParamForEstimate) (*types.
 	return &result, nil
 }
 
+func (c *Client) GetPrepTerm() (*types.PrepTerm, error) {
+
+	param := types.CallParam{
+		FromAddress: types.Address(fmt.Sprintf("hx%s", strings.Repeat("0", 40))),
+		ToAddress:   types.Address(genesisContract),
+		DataType:    "call",
+		Data: &types.CallData{
+			Method: MethodGetPrepTerm,
+			Params: map[string]string{},
+		},
+	}
+
+	var op types.PrepTerm
+	if err := c.Call(&param, &op); err != nil {
+		return nil, err
+	}
+	return &op, nil
+}
+
 func NewClient(uri string, l *zap.Logger) *Client {
 	//TODO options {MaxRetrySendTx, MaxRetryGetResult, MaxIdleConnsPerHost, Debug, Dump}
 	tr := &http.Transport{MaxIdleConnsPerHost: 1000}

relayer/chains/icon/methods.go

@@ -45,4 +45,7 @@ const (
 	MethodGetMissingPacketReceipts = "getMissingPacketReceipts"
 	MethodGetPacketHeights         = "getPacketHeights"
 	MethodGetAckHeights            = "getAckHeights"
+
+	//
+	MethodGetPrepTerm = "getPRepTerm"
 )

relayer/chains/icon/provider.go

@@ -104,15 +104,14 @@ func (pp *IconProviderConfig) NewProvider(log *zap.Logger, homepath string, debu
 		return nil, err
 	}
 
-	codec := MakeCodec(ModuleBasics, []string{})
-
 	return &IconProvider{
 		log:         log.With(zap.String("chain_id", pp.ChainID)),
 		client:      NewClient(pp.getRPCAddr(), log),
 		PCfg:        pp,
 		StartHeight: uint64(pp.StartHeight),
-		codec:       codec,
+		codec:       MakeCodec(ModuleBasics, []string{}),
 	}, nil
+
 }
 
 func (pp IconProviderConfig) getRPCAddr() string {

relayer/chains/icon/query.go

@@ -39,8 +39,9 @@ import (
 var _ provider.QueryProvider = &IconProvider{}
 
 const (
-	epoch         = 24 * 3600 * 1000
-	sequenceLimit = 2
+	epoch           = 24 * 3600 * 1000
+	sequenceLimit   = 2
+	genesisContract = "cx0000000000000000000000000000000000000000"
 )
 
 type CallParamOption func(*types.CallParam)
@@ -1015,3 +1016,62 @@ func (icp *IconProvider) HexStringToProtoUnmarshal(encoded string, v proto.Messa
 	return inputBytes, nil
 
 }
+
+func (ip *IconProvider) GetProofContextChangePeriod() (uint64, error) {
+	// assigning termPeriod
+	prep, err := ip.client.GetPrepTerm()
+	if err != nil {
+		return 0, fmt.Errorf("fail to get prepterm: %v", err)
+	}
+
+	decentralized, err := prep.IsDecentralized.Value()
+	if err != nil {
+		return 0, err
+	}
+
+	// storing  prep-term term only if decentralized
+	if decentralized == 1 {
+		period, err := prep.Period.Value()
+		if err != nil {
+			return 0, err
+		}
+		return uint64(period), nil
+
+	}
+	return 0, nil
+}
+
+func (ip *IconProvider) QueryProofContextChangeHeights(ctx context.Context, counterpartyClientHeight uint64, latestHeight uint64) ([]uint64, error) {
+	heights := make([]uint64, 0)
+	// querying prepterm
+
+	period, err := ip.GetProofContextChangePeriod()
+	if err != nil {
+		return heights, err
+	}
+
+	// 0 suggest that proof context period is not set
+	if period == 0 {
+		return heights, nil
+	}
+
+	// hasn't reached until the latest block
+	if counterpartyClientHeight+period > latestHeight {
+		return heights, nil
+	}
+
+	lastPeriodChangeHeight := counterpartyClientHeight - counterpartyClientHeight%period
+
+	for lastPeriodChangeHeight < latestHeight {
+		lastPeriodChangeHeight += period
+		btpblock, err := ip.GetBtpHeader(int64(lastPeriodChangeHeight + 1))
+		if err != nil {
+			continue
+		}
+		if btpblock != nil {
+			heights = append(heights, btpblock.MainHeight)
+		}
+	}
+
+	return heights, nil
+}

relayer/chains/icon/types/types.go

@@ -666,3 +666,23 @@ func (h *NetworkTypeSection) Encode() []byte {
 func (h *NetworkTypeSection) Hash() []byte {
 	return relayer_common.Sha3keccak256(h.Encode())
 }
+
+type PrepTerm struct {
+	BlockHeight      HexInt
+	bondRequirement  HexInt
+	EndBlockHeight   HexInt
+	IissVersion      HexInt
+	Irep             HexInt
+	IsDecentralized  HexInt
+	MainPRepCount    HexInt
+	Period           HexInt
+	Preps            interface{} //dont need right now
+	Revision         HexInt
+	RewardFund       interface{} //dont need right now
+	Rrep             HexInt
+	Sequence         HexInt
+	StartBlockHeight HexInt
+	TotalDelegated   HexInt
+	TotalPower       HexInt
+	TotalSupply      HexInt
+}

relayer/chains/penumbra/query.go

@@ -1005,3 +1005,6 @@ func (ap *PenumbraProvider) QueryMissingPacketReceipts(ctx context.Context, late
 func (ap *PenumbraProvider) QueryNextSeqSend(ctx context.Context, height int64, channelid, portid string) (seq uint64, err error) {
 	panic("QueryNextSeqSend not implemented")
 }
+func (ap *PenumbraProvider) QueryProofContextChangeHeights(ctx context.Context, counterpartyClientHeight uint64, height uint64) ([]uint64, error) {
+	panic("QueryProofContextChangeHeights not implemented")
+}

relayer/chains/wasm/query.go

@@ -1031,3 +1031,7 @@ func (ap *WasmProvider) QueryNextSeqSend(ctx context.Context, height int64, chan
 	}
 	return response, nil
 }
+
+func (ap *WasmProvider) QueryProofContextChangeHeights(ctx context.Context, counterpartyClientHeight uint64, height uint64) ([]uint64, error) {
+	panic("QueryProofContextChangeHeights not implemented")
+}

relayer/processor/path_end_runtime.go

@@ -391,6 +391,20 @@ func (pathEnd *pathEndRuntime) mergeCacheData(ctx context.Context, cancel func()
 	pathEnd.latestHeader = d.LatestHeader
 	pathEnd.clientState = d.ClientState
 
+	// from the last clientState update to latest header
+	// add all the proof context change height in btp
+	if d.IsGenesis && pathEnd.chainProvider.Type() == common.IconModule {
+
+		heights, _ := pathEnd.chainProvider.QueryProofContextChangeHeights(ctx,
+			counterParty.clientState.ConsensusHeight.RevisionHeight,
+			d.LatestHeader.Height())
+
+		for _, h := range heights {
+			pathEnd.BTPHeightQueue.Enqueue(h)
+
+		}
+	}
+
 	if pathEnd.chainProvider.Type() == common.IconModule && d.LatestHeader.IsCompleteBlock() {
 		pathEnd.BTPHeightQueue.Enqueue(d.LatestHeader.Height())
 	}

relayer/provider/provider.go

@@ -483,6 +483,9 @@ type QueryProvider interface {
 	// ics 20 - transfer
 	QueryDenomTrace(ctx context.Context, denom string) (*transfertypes.DenomTrace, error)
 	QueryDenomTraces(ctx context.Context, offset, limit uint64, height int64) ([]transfertypes.DenomTrace, error)
+
+	// For BTP
+	QueryProofContextChangeHeights(ctx context.Context, counterpartyClientHeight uint64, height uint64) ([]uint64, error)
 }
 
 type RelayPacket interface {