feat: update respective wasm client based on message sent from icon

relayer/chains/icon/provider.go

@@ -181,8 +181,9 @@ func (h IconIBCHeader) ConsensusState() ibcexported.ConsensusState {
 	}
 	return &icon.ConsensusState{}
 }
-func (h IconIBCHeader) ShouldUpdateWithZeroMessage() bool {
-	if h.Header != nil && h.Header.MessageCount == 0 {
+
+func (h IconIBCHeader) ShouldUpdateForProofContextChange() bool {
+	if h.Header != nil && h.Header.NextProofContext != nil {
 		return true
 	}
 	return false

relayer/chains/penumbra/provider.go

@@ -142,7 +142,7 @@ func (h PenumbraIBCHeader) IsCompleteBlock() bool {
 	return true
 }
 
-func (h PenumbraIBCHeader) ShouldUpdateWithZeroMessage() bool {
+func (h PenumbraIBCHeader) ShouldUpdateForProofContextChange() bool {
 	return false
 }
 

relayer/chains/wasm/provider.go

@@ -185,7 +185,7 @@ func (a WasmIBCHeader) NextValidatorsHash() []byte {
 	return a.SignedHeader.Header.NextValidatorsHash
 }
 
-func (a WasmIBCHeader) ShouldUpdateWithZeroMessage() bool {
+func (a WasmIBCHeader) ShouldUpdateForProofContextChange() bool {
 	return false
 }
 

relayer/processor/path_end_runtime.go

@@ -391,10 +391,6 @@ func (pathEnd *pathEndRuntime) mergeCacheData(ctx context.Context, cancel func()
 	pathEnd.latestHeader = d.LatestHeader
 	pathEnd.clientState = d.ClientState
 
-	if pathEnd.chainProvider.Type() == common.IconModule && d.LatestHeader.IsCompleteBlock() {
-		pathEnd.BTPHeightQueue.Enqueue(BlockInfoHeight{Height: int64(d.LatestHeader.Height()), IsProcessing: false})
-	}
-
 	terminate, err := pathEnd.checkForMisbehaviour(ctx, pathEnd.clientState, counterParty)
 	if err != nil {
 		pathEnd.log.Error(
@@ -424,10 +420,80 @@ func (pathEnd *pathEndRuntime) mergeCacheData(ctx context.Context, cancel func()
 
 	pathEnd.mergeMessageCache(d.IBCMessagesCache, counterpartyChainID, pathEnd.inSync && counterpartyInSync) // Merge incoming packet IBC messages into the backlog
 
+	pathEnd.updateBTPQueue(d, counterpartyChainID)
+
 	pathEnd.ibcHeaderCache.Merge(d.IBCHeaderCache)  // Update latest IBC header state
 	pathEnd.ibcHeaderCache.Prune(ibcHeadersToCache) // Only keep most recent IBC headers
 }
 
+// handle update for icon btp blocks.
+// When btp blocks are produced, forward them only to chain which the message is directed for.
+// However, when proof context changes, update has to be sent
+func (pathEnd *pathEndRuntime) updateBTPQueue(d ChainProcessorCacheData, counterpartyChainID string) {
+	if pathEnd.chainProvider.Type() != common.IconModule {
+		return
+	}
+
+	btpHeightKey := BlockInfoHeight{Height: int64(d.LatestHeader.Height()), IsProcessing: false}
+	if d.LatestHeader.ShouldUpdateForProofContextChange() {
+		pathEnd.BTPHeightQueue.Enqueue(btpHeightKey)
+		return
+	}
+
+	for k := range d.IBCMessagesCache.PacketFlow {
+		ck := ChannelKey{
+			ChannelID:             k.ChannelID,
+			PortID:                k.PortID,
+			CounterpartyChannelID: k.CounterpartyChannelID,
+			CounterpartyPortID:    k.CounterpartyPortID,
+		}
+
+		if pathEnd.channelStateCache[ck] && d.LatestHeader.IsCompleteBlock() {
+
+			pathEnd.log.Info("This packet message is directed",
+				zap.String("to", counterpartyChainID),
+				zap.Uint64("height", d.LatestHeader.Height()),
+			)
+			if !pathEnd.BTPHeightQueue.ItemExist(btpHeightKey) {
+				pathEnd.BTPHeightQueue.Enqueue(btpHeightKey)
+				return
+			}
+		}
+	}
+
+	// handle for connection handshake
+	for _, v := range d.IBCMessagesCache.ConnectionHandshake {
+		for k := range v {
+			if k.ClientID == pathEnd.info.ClientID {
+				pathEnd.log.Info("This connection handshake message is directed",
+					zap.String("to", counterpartyChainID),
+					zap.Uint64("height", d.LatestHeader.Height()),
+				)
+				if !pathEnd.BTPHeightQueue.ItemExist(btpHeightKey) {
+					pathEnd.BTPHeightQueue.Enqueue(btpHeightKey)
+					return
+				}
+			}
+		}
+	}
+
+	// handle for channel handshake
+	for _, v := range d.IBCMessagesCache.ChannelHandshake {
+		for _, x := range v {
+			if pathEnd.isRelevantConnection(x.ConnID) {
+				pathEnd.log.Info("This channel handshake message is directed",
+					zap.String("to", counterpartyChainID),
+					zap.Uint64("height", d.LatestHeader.Height()),
+				)
+				if !pathEnd.BTPHeightQueue.ItemExist(btpHeightKey) {
+					pathEnd.BTPHeightQueue.Enqueue(btpHeightKey)
+					return
+				}
+			}
+		}
+	}
+}
+
 // shouldSendPacketMessage determines if the packet flow message should be sent now.
 // It will also determine if the message needs to be given up on entirely and remove retention if so.
 func (pathEnd *pathEndRuntime) shouldSendPacketMessage(message packetIBCMessage, counterparty *pathEndRuntime) bool {

relayer/processor/types_test.go

@@ -14,7 +14,7 @@ func (h mockIBCHeader) Height() uint64                             { return 0 }
 func (h mockIBCHeader) ConsensusState() ibcexported.ConsensusState { return nil }
 func (h mockIBCHeader) NextValidatorsHash() []byte                 { return nil }
 func (h mockIBCHeader) IsCompleteBlock() bool                      { return true }
-func (h mockIBCHeader) ShouldUpdateWithZeroMessage() bool          { return false }
+func (h mockIBCHeader) ShouldUpdateForProofContextChange() bool    { return false }
 
 func TestIBCHeaderCachePrune(t *testing.T) {
 	cache := make(processor.IBCHeaderCache)

relayer/provider/provider.go

@@ -63,8 +63,8 @@ type IBCHeader interface {
 	Height() uint64
 	ConsensusState() ibcexported.ConsensusState
 	NextValidatorsHash() []byte
-	IsCompleteBlock() bool             //defined for IconIBCHeader
-	ShouldUpdateWithZeroMessage() bool //defined for IconIBCHeader
+	IsCompleteBlock() bool                   //defined for IconIBCHeader
+	ShouldUpdateForProofContextChange() bool //defined for IconIBCHeader
 }
 
 // ClientState holds the current state of a client from a single chain's perspective
@@ -553,7 +553,7 @@ func (h TendermintIBCHeader) ConsensusState() ibcexported.ConsensusState {
 func (h TendermintIBCHeader) IsCompleteBlock() bool {
 	return true
 }
-func (h TendermintIBCHeader) ShouldUpdateWithZeroMessage() bool {
+func (h TendermintIBCHeader) ShouldUpdateForProofContextChange() bool {
 	return false
 }