fix: packet retention not clear

relayer/chains/icon/icon_chain_processor.go

@@ -154,22 +154,22 @@
 	return err
 }
 
 func (icp *IconChainProcessor) StartFromHeight(ctx context.Context) int {
 	cfg := icp.Provider().ProviderConfig().(*IconProviderConfig)
 	if cfg.StartHeight != 0 {
 		return int(cfg.StartHeight)
 	}
 	snapshotHeight, err := rlycommon.LoadSnapshotHeight(icp.Provider().ChainId())
 	if err != nil {
 		icp.log.Warn("Failed to load height from snapshot", zap.Error(err))
 	} else {
 		icp.log.Info("Obtained start height from config", zap.Int("height", snapshotHeight))
 	}
 	return snapshotHeight
 }
 
 func (icp *IconChainProcessor) initializeConnectionState(ctx context.Context) error {
 	// TODO: review
 	ctx, cancel := context.WithTimeout(ctx, queryTimeout)
 	defer cancel()
 
@@ -264,19 +264,19 @@
 	}
 
 	var err error
 	// processedheight := int64(icp.chainProvider.lastBTPBlockHeight)
 	// if processedheight == 0 {
 	processedheight := int64(icp.StartFromHeight(ctx))
 	if processedheight <= 0 {
 		processedheight, err = icp.chainProvider.QueryLatestHeight(ctx)
 		if err != nil {
 			fmt.Println("Error fetching latest block")
 			return err
 		}
 	}
 	// }
 
 	icp.log.Debug("Start to query from height", zap.Int64("height", processedheight))
 	// subscribe to monitor block
 	ctxMonitorBlock, cancelMonitorBlock := context.WithCancel(ctx)
 	reconnect()
@@ -286,7 +286,7 @@
 	icp.firstTime = true
 
 	blockReq := &types.BlockRequest{
 		Height:       types.NewHexInt(int64(icp.chainProvider.PCfg.StartHeight)),
 		EventFilters: GetMonitorEventFilters(icp.chainProvider.PCfg.IbcHandlerAddress),
 	}
 
@@ -313,7 +313,7 @@
 				}, func(conn *websocket.Conn) {
 				}, func(conn *websocket.Conn, err error) {})
 				if err != nil {
 					icp.SnapshotHeight(int(processedheight) - 5)
 					if errors.Is(err, context.Canceled) {
 						return
 					}
@@ -325,15 +325,15 @@
 			}(ctxMonitorBlock, cancelMonitorBlock)
 		case br := <-btpBlockRespCh:
 			for ; br != nil; processedheight++ {
 				// verify BTP Block
 				err := icp.verifyBlock(ctx, br.Header)
 				if err != nil {
 					reconnect()
 					icp.log.Warn("failed to Verify BTP Block",
 						zap.Int64("got", br.Height),
 						zap.Error(err),
 					)
 					break
 				}
 
 				icp.latestBlock = provider.LatestBlock{
@@ -351,7 +351,7 @@
 				icp.log.Info("Queried Latest height: ",
 					zap.String("chain id ", icp.chainProvider.ChainId()),
 					zap.Int64("height", br.Height))
-				err = icp.handlePathProcessorUpdate(ctx, br.Header, ibcMessageCache, ibcHeaderCache)
+				err = icp.handlePathProcessorUpdate(ctx, br.Header, ibcMessageCache, ibcHeaderCache.Clone())
 				if err != nil {
 					reconnect()
 					icp.log.Warn("Reconnect: error occured during handle block response  ",
@@ -359,12 +359,12 @@
 					)
 					break
 				}
 				time.Sleep(10 * time.Millisecond)
 				icp.firstTime = false
 				if br = nil; len(btpBlockRespCh) > 0 {
 					br = <-btpBlockRespCh
 				}
 				icp.SnapshotHeight(int(icp.latestBlock.Height) - 5)
 			}
 			// remove unprocessed blockResponses
 			for len(btpBlockRespCh) > 0 {
@@ -455,78 +455,78 @@
 	}
 }
 
 func (icp *IconChainProcessor) SnapshotHeight(height int) {
 
 	blockInterval := icp.Provider().ProviderConfig().GetBlockInterval()
 	snapshotThreshold := rlycommon.ONE_HOUR / int(blockInterval)
 
 	retryAfter := icp.Provider().ProviderConfig().GetFirstRetryBlockAfter()
 	snapshotHeight := height - int(retryAfter)
 
 	if snapshotHeight%snapshotThreshold == 0 {
 		err := rlycommon.SnapshotHeight(icp.Provider().ChainId(), height)
 		if err != nil {
 			icp.log.Warn("Failed saving height snapshot for height", zap.Int("height", height))
 		}
 	}
 }
 
 func (icp *IconChainProcessor) verifyBlock(ctx context.Context, ibcHeader provider.IBCHeader) error {
 	header, ok := ibcHeader.(IconIBCHeader)
 	if !ok {
 		return fmt.Errorf("Provided Header is not compatible with IBCHeader")
 	}
 	if icp.firstTime {
 		proofContext, err := icp.chainProvider.GetProofContextByHeight(int64(header.MainHeight) - 1)
 		if err != nil {
 			return err
 		}
 		icp.verifier = &Verifier{
 			nextProofContext: proofContext,
 			verifiedHeight:   int64(header.MainHeight) - 1,
 		}
 	}
 
 	if !ibcHeader.IsCompleteBlock() {
 		icp.verifier.nextProofContext = header.Validators
 		icp.verifier.verifiedHeight = int64(header.Height())
 		return nil
 	}
 
 	// prevNetworkSectionHash would be nil for first block
 	if icp.verifier.prevNetworkSectionHash != nil &&
 		!bytes.Equal(icp.verifier.prevNetworkSectionHash, header.Header.PrevNetworkSectionHash) {
 		return fmt.Errorf("failed to match prevNetworkSectionHash")
 	}
 
 	sigs, err := icp.chainProvider.GetBTPProof(int64(header.MainHeight))
 	if err != nil {
 		return err
 	}
 
 	decision := types.NewNetworkTypeSectionDecision(
 		getSrcNetworkId(icp.chainProvider.PCfg.ICONNetworkID),
 		icp.chainProvider.PCfg.BTPNetworkTypeID,
 		int64(header.MainHeight),
 		header.Header.Round,
 		types.NetworkTypeSection{
 			NextProofContextHash: header.Header.NextProofContextHash,
 			NetworkSectionsRoot:  GetNetworkSectionRoot(header.Header),
 		})
 
 	valid, err := VerifyBtpProof(decision, sigs, icp.verifier.nextProofContext)
 	if err != nil {
 		return err
 	}
 
 	if !valid {
 		return fmt.Errorf("failed to Verify block")
 	}
 
 	icp.verifier.nextProofContext = header.Validators
 	icp.verifier.verifiedHeight = int64(header.Height())
 	icp.verifier.prevNetworkSectionHash = types.NewNetworkSection(header.Header).Hash()
 	return nil
 }
 
 func (icp *IconChainProcessor) handleBTPBlockRequest(
@@ -662,7 +662,7 @@
 			ClientState:          clientState,
 			ConnectionStateCache: icp.connectionStateCache.FilterForClient(clientID),
 			ChannelStateCache:    icp.channelStateCache.FilterForClient(clientID, icp.channelConnections, icp.connectionClients),
 			IBCHeaderCache:       ibcHeaderCache.Clone(),
 			IsGenesis:            icp.firstTime,
 		})
 	}
@@ -673,9 +673,9 @@
 // clientState will return the most recent client state if client messages
 // have already been observed for the clientID, otherwise it will query for it.
 func (icp *IconChainProcessor) clientState(ctx context.Context, clientID string) (provider.ClientState, error) {
 	if state, ok := icp.latestClientState[clientID]; ok {
 		return state, nil
 	}
 	cs, err := icp.chainProvider.QueryClientStateWithoutProof(ctx, int64(icp.latestBlock.Height), clientID)
 	if err != nil {
 		return provider.ClientState{}, err

relayer/chains/icon/query.go

@@ -38,8 +38,7 @@
 var _ provider.QueryProvider = &IconProvider{}
 
 const (
-	epoch            = 24 * 3600 * 1000
-	clientNameString = "07-tendermint-"
+	epoch = 24 * 3600 * 1000
 )
 
 type CallParamOption func(*types.CallParam)
@@ -82,12 +81,12 @@
 
 // required for cosmos only
 func (icp *IconProvider) QueryTx(ctx context.Context, hashHex string) (*provider.RelayerTxResponse, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 // required for cosmos only
 func (icp *IconProvider) QueryTxs(ctx context.Context, page, limit int, events []string) ([]*provider.RelayerTxResponse, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryLatestHeight(ctx context.Context) (int64, error) {
@@ -126,11 +125,11 @@
 }
 
 func (icp *IconProvider) QuerySendPacket(ctx context.Context, srcChanID, srcPortID string, sequence uint64) (provider.PacketInfo, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryRecvPacket(ctx context.Context, dstChanID, dstPortID string, sequence uint64) (provider.PacketInfo, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryBalance(ctx context.Context, keyName string) (sdk.Coins, error) {
@@ -144,17 +143,17 @@
 
 // implementing is not required
 func (icp *IconProvider) QueryBalanceWithAddress(ctx context.Context, addr string) (sdk.Coins, error) {
 	param := types.AddressParam{
 		Address: types.Address(addr),
 	}
 	balance, err := icp.client.GetBalance(&param)
 	if err != nil {
 		return nil, err
 	}
 	return sdk.Coins{sdk.Coin{
 		Denom:  "ICX",
 		Amount: math.NewInt(balance.Int64()),
 	}}, nil
 }
 
 func (icp *IconProvider) QueryUnbondingPeriod(context.Context) (time.Duration, error) {
@@ -293,15 +292,15 @@
 }
 
 func (icp *IconProvider) QueryUpgradedClient(ctx context.Context, height int64) (*clienttypes.QueryClientStateResponse, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryUpgradedConsState(ctx context.Context, height int64) (*clienttypes.QueryConsensusStateResponse, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryConsensusState(ctx context.Context, height int64) (ibcexported.ConsensusState, int64, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 // query all the clients of the chain
@@ -318,7 +317,7 @@
 
 	identifiedClientStates := make(clienttypes.IdentifiedClientStates, 0)
 	for i := 0; i <= int(seq)-1; i++ {
-		clientIdentifier := fmt.Sprintf("%s%d", clientNameString, i)
+		clientIdentifier := common.GetIdentifier(common.TendermintLightClient, i)
 		callParams := icp.prepareCallParams(MethodGetClientState, map[string]interface{}{
 			"clientId": clientIdentifier,
 		})
@@ -407,7 +406,7 @@
 	}
 
 	for i := 0; i <= int(nextSeq)-1; i++ {
-		connectionId := fmt.Sprintf("connection-%d", i)
+		connectionId := common.GetIdentifier(common.ConnectionKey, i)
 		var conn_string_ types.HexBytes
 		err := icp.client.Call(icp.prepareCallParams(MethodGetConnection, map[string]interface{}{
 			"connectionId": connectionId,
@@ -424,7 +423,7 @@
 			continue
 		}
 		// Only return open conenctions
 		if conn.State == conntypes.OPEN {
 			identifiedConn := conntypes.IdentifiedConnection{
 				Id:           connectionId,
 				ClientId:     conn.ClientId,
@@ -476,7 +475,7 @@
 }
 
 func (icp *IconProvider) QueryConnectionsUsingClient(ctx context.Context, height int64, clientid string) (*conntypes.QueryConnectionsResponse, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 func (icp *IconProvider) GenerateConnHandshakeProof(ctx context.Context, height int64, clientId, connId string) (ibcexported.ClientState,
 	[]byte, []byte, []byte,
@@ -571,7 +570,7 @@
 )
 
 func (icp *IconProvider) QueryChannelClient(ctx context.Context, height int64, channelid, portid string) (*clienttypes.IdentifiedClientState, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 // is not needed currently for the operation
@@ -609,7 +608,7 @@
 
 	for i := 0; i <= int(nextSeq)-1; i++ {
 		for _, portId := range allPorts {
-			channelId := fmt.Sprintf("channel-%d", i)
+			channelId := common.GetIdentifier(common.ChannelKey, i)
 			var _channel types.HexBytes
 			err := icp.client.Call(icp.prepareCallParams(MethodGetChannel, map[string]interface{}{
 				"channelId": channelId,
@@ -634,7 +633,7 @@
 			}
 
 			// check if the channel is open
 			if channel.State == chantypes.OPEN {
 				identifiedChannel := chantypes.IdentifiedChannel{
 					State:          channel.State,
 					Ordering:       channel.Ordering,
@@ -654,19 +653,19 @@
 
 // required to flush packets
 func (icp *IconProvider) QueryPacketCommitments(ctx context.Context, height uint64, channelid, portid string) (commitments *chantypes.QueryPacketCommitmentsResponse, err error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryPacketAcknowledgements(ctx context.Context, height uint64, channelid, portid string) (acknowledgements []*chantypes.PacketState, err error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryUnreceivedPackets(ctx context.Context, height uint64, channelid, portid string, seqs []uint64) ([]uint64, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryUnreceivedAcknowledgements(ctx context.Context, height uint64, channelid, portid string, seqs []uint64) ([]uint64, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryNextSeqRecv(ctx context.Context, height int64, channelid, portid string) (recvRes *chantypes.QueryNextSequenceReceiveResponse, err error) {
@@ -791,12 +790,12 @@
 // ics 20 - transfer
 // not required for icon
 func (icp *IconProvider) QueryDenomTrace(ctx context.Context, denom string) (*transfertypes.DenomTrace, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 // not required for icon
 func (icp *IconProvider) QueryDenomTraces(ctx context.Context, offset, limit uint64, height int64) ([]transfertypes.DenomTrace, error) {
 	panic(fmt.Sprintf("%s%s", icp.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (icp *IconProvider) QueryIconProof(ctx context.Context, height int64, keyHash []byte) ([]byte, error) {

relayer/chains/icon/tx.go

@@ -34,7 +34,7 @@
 )
 
 func (icp *IconProvider) MsgCreateClient(clientState ibcexported.ClientState, consensusState ibcexported.ConsensusState) (provider.RelayerMessage, error) {
 
 	clientStateBytes, err := proto.Marshal(clientState)
 	if err != nil {
 		return nil, err
@@ -500,26 +500,26 @@
 		return nil, err
 	}
 
 	var currentValidatorList types.ValidatorList
 	// subtract 1 because it is a current validator not last validator
 	info, err := icp.client.GetNetworkTypeInfo(int64(latestIconHeader.Header.MainHeight-1), icp.PCfg.BTPNetworkTypeID)
 	if err != nil {
 		return nil, err
 	}
 
 	_, err = Base64ToData(string(info.NextProofContext), &currentValidatorList)
 	if err != nil {
 		return nil, err
 	}
 
 	var nextValidators types.ValidatorList
 	// subtract 1 because it is a current validator not last validator
 	next_info, err := icp.client.GetNetworkTypeInfo(int64(latestIconHeader.Header.MainHeight), icp.PCfg.BTPNetworkTypeID)
 	if err != nil {
 		return nil, err
 	}
 
 	_, err = Base64ToData(string(next_info.NextProofContext), &nextValidators)
 	if err != nil {
 		return nil, err
 	}
@@ -535,11 +535,11 @@
 			PrevNetworkSectionHash: latestIconHeader.Header.PrevNetworkSectionHash,
 			MessageCount:           latestIconHeader.Header.MessageCount,
 			MessageRoot:            latestIconHeader.Header.MessageRoot,
 			NextValidators:         nextValidators.Validators,
 		},
 		Signatures:        btp_proof,
 		TrustedHeight:     trustedHeight.RevisionHeight,
 		CurrentValidators: currentValidatorList.Validators,
 	}
 
 	return signedHeader, nil
@@ -738,7 +738,7 @@
 	// If update fails, the subsequent txn will fail, result of update not being fetched concurrently
 	switch m.Method {
 	case MethodUpdateClient:
-		icp.WaitForTxResult(asyncCtx, txhash, m.Method, defaultBroadcastWaitTimeout, asyncCallback)
+		return icp.WaitForTxResult(asyncCtx, txhash, m.Method, defaultBroadcastWaitTimeout, asyncCallback)
 	default:
 		go icp.WaitForTxResult(asyncCtx, txhash, m.Method, defaultBroadcastWaitTimeout, asyncCallback)
 	}
@@ -753,20 +753,20 @@
 	method string,
 	timeout time.Duration,
 	callback func(*provider.RelayerTxResponse, error),
-) {
+) error {
 	txhash := types.NewHexBytes(txHash)
 	_, txRes, err := icp.client.WaitForResults(asyncCtx, &types.TransactionHashParam{Hash: txhash})
 	if err != nil {
 		icp.log.Error("Failed to get txn result", zap.String("txHash", string(txhash)), zap.String("method", method), zap.Error(err))
 		if callback != nil {
 			callback(nil, err)
 		}
-		return
+		return err
 	}
 
 	height, err := txRes.BlockHeight.Value()
 	if err != nil {
-		return
+		return err
 	}
 
 	var eventLogs []provider.RelayerEvent
@@ -787,7 +787,7 @@
 			callback(nil, err)
 		}
 		icp.LogFailedTx(method, txRes, err)
-		return
+		return err
 
 	}
 
@@ -803,6 +803,7 @@
 	}
 	// log successful txn
 	icp.LogSuccessTx(method, txRes)
+	return nil
 }
 
 func (icp *IconProvider) LogSuccessTx(method string, result *types.TransactionResult) {

relayer/chains/wasm/query.go

@@ -39,7 +39,7 @@
 	NOT_IMPLEMENTED = " :: Not implemented for WASM"
 )
 
 func (ap *WasmProvider) QueryTx(ctx context.Context, hashHex string) (*provider.RelayerTxResponse, error) {
 	hash, err := hex.DecodeString(hashHex)
 	if err != nil {
 		return nil, err
@@ -61,7 +61,7 @@
 	}, nil
 
 }
 func (ap *WasmProvider) QueryTxs(ctx context.Context, page, limit int, events []string) ([]*provider.RelayerTxResponse, error) {
 	if len(events) == 0 {
 		return nil, errors.New("must declare at least one event to search")
 	}
@@ -115,7 +115,7 @@
 	return events
 }
 
 func (ap *WasmProvider) QueryLatestHeight(ctx context.Context) (int64, error) {
 
 	stat, err := ap.RPCClient.Status(ctx)
 	if err != nil {
@@ -127,7 +127,7 @@
 }
 
 // QueryIBCHeader returns the IBC compatible block header at a specific height.
 func (ap *WasmProvider) QueryIBCHeader(ctx context.Context, h int64) (provider.IBCHeader, error) {
 	if h == 0 {
 		return nil, fmt.Errorf("No header at height 0")
 	}
@@ -136,31 +136,31 @@
 		return nil, err
 	}
 
 	return NewWasmIBCHeaderFromLightBlock(lightBlock), nil
 }
 
 func (ap *WasmProvider) QueryLightBlock(ctx context.Context, h int64) (provider.IBCHeader, *tmtypes.LightBlock, error) {
 	if h == 0 {
 		return nil, nil, fmt.Errorf("No header at height 0")
 	}
 	lightBlock, err := ap.LightProvider.LightBlock(ctx, h)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	return NewWasmIBCHeaderFromLightBlock(lightBlock), lightBlock, nil
 }
 
 // query packet info for sequence
 func (ap *WasmProvider) QuerySendPacket(ctx context.Context, srcChanID, srcPortID string, sequence uint64) (provider.PacketInfo, error) {
 	return provider.PacketInfo{}, fmt.Errorf("Not implemented for Wasm")
 }
 func (ap *WasmProvider) QueryRecvPacket(ctx context.Context, dstChanID, dstPortID string, sequence uint64) (provider.PacketInfo, error) {
 	return provider.PacketInfo{}, fmt.Errorf("Not implemented for Wasm")
 }
 
 // bank
 func (ap *WasmProvider) QueryBalance(ctx context.Context, keyName string) (sdk.Coins, error) {
 	addr, err := ap.ShowAddress(keyName)
 	if err != nil {
 		return nil, err
@@ -169,7 +169,7 @@
 	return ap.QueryBalanceWithAddress(ctx, addr)
 }
 
 func (ap *WasmProvider) QueryBalanceWithAddress(ctx context.Context, address string) (sdk.Coins, error) {
 	qc := bankTypes.NewQueryClient(ap)
 	p := DefaultPageRequest()
 	coins := sdk.Coins{}
@@ -205,13 +205,13 @@
 }
 
 // staking
 func (ap *WasmProvider) QueryUnbondingPeriod(context.Context) (time.Duration, error) {
 	// move to provider, panic
 	return 0, nil
 }
 
 // ics 02 - client
 func (ap *WasmProvider) QueryClientState(ctx context.Context, height int64, clientid string) (ibcexported.ClientState, error) {
 	clientStateRes, err := ap.QueryClientStateResponse(ctx, height, clientid)
 	if err != nil {
 		return nil, err
@@ -225,7 +225,7 @@
 }
 
 // TODO: Check revision number
 func (ap *WasmProvider) QueryClientStateResponse(ctx context.Context, height int64, srcClientId string) (*clienttypes.QueryClientStateResponse, error) {
 
 	clS, err := ap.QueryClientStateContract(ctx, srcClientId)
 	if err != nil {
@@ -237,7 +237,7 @@
 	}
 
 	storageKey := getStorageKeyFromPath(common.GetClientStateCommitmentKey(srcClientId))
 	proof, err := ap.QueryWasmProof(ctx, storageKey, height)
 	if err != nil {
 		return nil, err
 	}
@@ -249,7 +249,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) QueryClientStateContract(ctx context.Context, clientId string) (*icon.ClientState, error) {
 	clientStateParam, err := types.NewClientState(clientId).Bytes()
 	if err != nil {
 		return nil, err
@@ -275,7 +275,7 @@
 	return iconClientState, nil
 }
 
 func (ap *WasmProvider) QueryConnectionContract(ctx context.Context, connId string) (*conntypes.ConnectionEnd, error) {
 	connStateParam, err := types.NewConnection(connId).Bytes()
 	if err != nil {
 		return nil, err
@@ -294,7 +294,7 @@
 	return &connS, nil
 }
 
 func (ap *WasmProvider) QueryChannelContract(ctx context.Context, portId, channelId string) (*chantypes.Channel, error) {
 	channelStateParam, err := types.NewChannel(portId, channelId).Bytes()
 	if err != nil {
 		return nil, err
@@ -312,7 +312,7 @@
 	return &channelS, nil
 }
 
 func (ap *WasmProvider) QueryClientConsensusState(ctx context.Context, chainHeight int64, clientid string, clientHeight ibcexported.Height) (*clienttypes.QueryConsensusStateResponse, error) {
 	consensusStateParam, err := types.NewConsensusState(clientid, uint64(chainHeight)).Bytes()
 	consensusState, err := ap.QueryIBCHandlerContractProcessed(ctx, consensusStateParam)
 	if err != nil {
@@ -332,7 +332,7 @@
 	return clienttypes.NewQueryConsensusStateResponse(anyConsensusState, nil, clienttypes.NewHeight(0, uint64(chainHeight))), nil
 }
 
 func (ap *WasmProvider) QueryIBCHandlerContract(ctx context.Context, param wasmtypes.RawContractMessage) (*wasmtypes.QuerySmartContractStateResponse, error) {
 
 	return ap.QueryClient.SmartContractState(ctx, &wasmtypes.QuerySmartContractStateRequest{
 		Address:   ap.PCfg.IbcHandlerAddress,
@@ -340,7 +340,7 @@
 	})
 }
 
 func (ap *WasmProvider) QueryIBCHandlerContractProcessed(ctx context.Context, param wasmtypes.RawContractMessage) ([]byte, error) {
 	res, err := ap.QueryIBCHandlerContract(ctx, param)
 	if err != nil {
 		return nil, err
@@ -348,15 +348,15 @@
 	return ProcessContractResponse(res)
 }
 
 func (ap *WasmProvider) QueryUpgradedClient(ctx context.Context, height int64) (*clienttypes.QueryClientStateResponse, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryUpgradedConsState(ctx context.Context, height int64) (*clienttypes.QueryConsensusStateResponse, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryConsensusState(ctx context.Context, height int64) (ibcexported.ConsensusState, int64, error) {
 
 	commit, err := ap.RPCClient.Commit(ctx, &height)
 	if err != nil {
@@ -381,7 +381,7 @@
 	return state, height, nil
 }
 
 func (ap *WasmProvider) getAllPorts(ctx context.Context) ([]string, error) {
 	param, err := types.NewGetAllPorts().Bytes()
 	if err != nil {
 		return make([]string, 0), err
@@ -399,7 +399,7 @@
 	return ports, nil
 }
 
 func (ap *WasmProvider) getNextSequence(ctx context.Context, methodName string) (int, error) {
 	switch methodName {
 	case MethodGetNextClientSequence:
 		param, err := types.NewNextClientSequence().Bytes()
@@ -441,7 +441,7 @@
 	}
 }
 
 func (ap *WasmProvider) QueryClients(ctx context.Context) (clienttypes.IdentifiedClientStates, error) {
 
 	seq, err := ap.getNextSequence(ctx, MethodGetNextClientSequence)
 	if err != nil {
@@ -454,7 +454,7 @@
 
 	identifiedClientStates := make(clienttypes.IdentifiedClientStates, 0)
 	for i := 0; i <= int(seq)-1; i++ {
-		clientIdentifier := fmt.Sprintf("%s-%d", ClientPrefix, i)
+		clientIdentifier := common.GetIdentifier(common.IconLightClient, i)
 		clientState, err := ap.QueryClientStateContract(ctx, clientIdentifier)
 		if err != nil {
 			return nil, err
@@ -466,7 +466,7 @@
 }
 
 // ics 03 - connection
 func (ap *WasmProvider) QueryConnection(ctx context.Context, height int64, connectionid string) (*conntypes.QueryConnectionResponse, error) {
 	connectionStateParams, err := types.NewConnection(connectionid).Bytes()
 	if err != nil {
 		return nil, err
@@ -484,12 +484,12 @@
 	}
 
 	storageKey := getStorageKeyFromPath(common.GetConnectionCommitmentKey(connectionid))
 	connProof, err := ap.QueryWasmProof(ctx, storageKey, height)
 
 	return conntypes.NewQueryConnectionResponse(conn, connProof, clienttypes.NewHeight(0, uint64(height))), nil
 }
 
 func (ap *WasmProvider) QueryWasmProof(ctx context.Context, storageKey []byte, height int64) ([]byte, error) {
 	ibcAddr, err := sdk.AccAddressFromBech32(ap.PCfg.IbcHandlerAddress)
 	if err != nil {
 		return nil, err
@@ -533,7 +533,7 @@
 
 }
 
 func (ap *WasmProvider) QueryConnections(ctx context.Context) (conns []*conntypes.IdentifiedConnection, err error) {
 
 	seq, err := ap.getNextSequence(ctx, MethodGetNextConnectionSequence)
 	if err != nil {
@@ -545,14 +545,14 @@
 	}
 
 	for i := 0; i <= int(seq)-1; i++ {
-		connectionId := fmt.Sprintf("%s-%d", ConnectionPrefix, i)
+		connectionId := common.GetIdentifier(common.ConnectionKey, i)
 		conn, err := ap.QueryConnectionContract(ctx, connectionId)
 		if err != nil {
 			continue
 		}
 
 		// Only return open conenctions
 		if conn.State == conntypes.OPEN {
 			identifiedConn := conntypes.IdentifiedConnection{
 				Id:           connectionId,
 				ClientId:     conn.ClientId,
@@ -568,8 +568,8 @@
 	return conns, nil
 }
 
 func (ap *WasmProvider) QueryConnectionsUsingClient(ctx context.Context, height int64, clientid string) (*conntypes.QueryConnectionsResponse, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) GenerateConnHandshakeProof(ctx context.Context, height int64, clientId, connId string) (clientState ibcexported.ClientState,
@@ -588,14 +588,14 @@
 	}
 
 	connStorageKey := getStorageKeyFromPath(common.GetConnectionCommitmentKey(connId))
 	proofConnBytes, err := ap.QueryWasmProof(ctx, connStorageKey, height)
 	if err != nil {
 		return nil, nil, nil, nil, nil, err
 
 	}
 
 	consStorageKey := getStorageKeyFromPath(common.GetConsensusStateCommitmentKey(clientId, big.NewInt(0), big.NewInt(height)))
 	proofConsensusBytes, err := ap.QueryWasmProof(ctx, consStorageKey, height)
 	if err != nil {
 		return nil, nil, nil, nil, nil, err
 	}
@@ -603,7 +603,7 @@
 }
 
 // ics 04 - channel
 func (ap *WasmProvider) QueryChannel(ctx context.Context, height int64, channelid, portid string) (chanRes *chantypes.QueryChannelResponse, err error) {
 	channelParams, err := types.NewChannel(portid, channelid).Bytes()
 	if err != nil {
 		return nil, err
@@ -624,16 +624,16 @@
 	}
 
 	storageKey := getStorageKeyFromPath(common.GetChannelCommitmentKey(portid, channelid))
 	proof, err := ap.QueryWasmProof(ctx, storageKey, height)
 
 	return chantypes.NewQueryChannelResponse(channelS, proof, clienttypes.NewHeight(0, uint64(height))), nil
 }
 
 func (ap *WasmProvider) QueryChannelClient(ctx context.Context, height int64, channelid, portid string) (*clienttypes.IdentifiedClientState, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryConnectionChannels(ctx context.Context, height int64, connectionid string) ([]*chantypes.IdentifiedChannel, error) {
 	allChannel, err := ap.QueryChannels(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("error querying Channels %v", err)
@@ -647,7 +647,7 @@
 	return identifiedChannels, nil
 }
 
 func (ap *WasmProvider) QueryChannels(ctx context.Context) ([]*chantypes.IdentifiedChannel, error) {
 	nextSeq, err := ap.getNextSequence(ctx, MethodGetNextChannelSequence)
 	if err != nil {
 		return nil, err
@@ -664,14 +664,14 @@
 
 	for i := 0; i <= int(nextSeq)-1; i++ {
 		for _, portId := range allPorts {
-			channelId := fmt.Sprintf("%s-%d", ChannelPrefix, i)
+			channelId := common.GetIdentifier(common.ChannelKey, i)
 			channel, err := ap.QueryChannelContract(ctx, portId, channelId)
 			if err != nil {
 				continue
 			}
 
 			// check if the channel is open
 			if channel.State == chantypes.OPEN {
 				identifiedChannel := chantypes.IdentifiedChannel{
 					State:          channel.State,
 					Ordering:       channel.Ordering,
@@ -689,23 +689,23 @@
 	return channels, nil
 }
 
 func (ap *WasmProvider) QueryPacketCommitments(ctx context.Context, height uint64, channelid, portid string) (commitments *chantypes.QueryPacketCommitmentsResponse, err error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryPacketAcknowledgements(ctx context.Context, height uint64, channelid, portid string) (acknowledgements []*chantypes.PacketState, err error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryUnreceivedPackets(ctx context.Context, height uint64, channelid, portid string, seqs []uint64) ([]uint64, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryUnreceivedAcknowledgements(ctx context.Context, height uint64, channelid, portid string, seqs []uint64) ([]uint64, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) QueryNextSeqRecv(ctx context.Context, height int64, channelid, portid string) (recvRes *chantypes.QueryNextSequenceReceiveResponse, err error) {
 	nextSeqRecvParams, err := types.NewNextSequenceReceive(portid, channelid).Bytes()
 	if err != nil {
 		return nil, err
@@ -715,7 +715,7 @@
 		return nil, err
 	}
 
 	proof, err := ap.QueryWasmProof(ctx, common.MustHexStrToBytes(STORAGEKEY__NextSequenceReceive), height)
 	if err != nil {
 		return nil, err
 	}
@@ -727,7 +727,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) QueryPacketCommitment(ctx context.Context, height int64, channelid, portid string, seq uint64) (comRes *chantypes.QueryPacketCommitmentResponse, err error) {
 	pktCommitmentParams, err := types.NewPacketCommitment(portid, channelid, seq).Bytes()
 	if err != nil {
 		return nil, err
@@ -737,7 +737,7 @@
 		return nil, err
 	}
 	storageKey := getStorageKeyFromPath(common.GetPacketCommitmentKey(portid, channelid, big.NewInt(int64(seq))))
 	proof, err := ap.QueryWasmProof(ctx, storageKey, height)
 
 	if err != nil {
 		return nil, err
@@ -750,7 +750,7 @@
 
 }
 
 func (ap *WasmProvider) QueryPacketAcknowledgement(ctx context.Context, height int64, channelid, portid string, seq uint64) (ackRes *chantypes.QueryPacketAcknowledgementResponse, err error) {
 	pktAcknowledgementParams, err := types.NewPacketAcknowledgementCommitment(portid, channelid, seq).Bytes()
 	if err != nil {
 		return nil, err
@@ -760,7 +760,7 @@
 		return nil, err
 	}
 	storageKey := getStorageKeyFromPath(common.GetPacketAcknowledgementCommitmentKey(portid, channelid, big.NewInt(int64(seq))))
 	proof, err := ap.QueryWasmProof(ctx, storageKey, height)
 
 	return &chantypes.QueryPacketAcknowledgementResponse{
 		Acknowledgement: pktAcknowledgement.Data.Bytes(),
@@ -769,11 +769,11 @@
 	}, nil
 }
 
 func (ap *WasmProvider) QueryPacketReceipt(ctx context.Context, height int64, channelid, portid string, seq uint64) (recRes *chantypes.QueryPacketReceiptResponse, err error) {
 
 	// getting proof from commitment map in contract
 	storageKey := getStorageKeyFromPath(common.GetPacketReceiptCommitmentKey(portid, channelid, big.NewInt(int64(seq))))
 	proof, err := ap.QueryWasmProof(ctx, storageKey, height)
 	if err != nil {
 		return nil, err
 	}
@@ -795,7 +795,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) GetCommitmentPrefixFromContract(ctx context.Context) ([]byte, error) {
 
 	pktCommitmentParams, err := types.NewCommitmentPrefix().Bytes()
 	if err != nil {
@@ -806,38 +806,38 @@
 }
 
 // ics 20 - transfer
 func (ap *WasmProvider) QueryDenomTrace(ctx context.Context, denom string) (*transfertypes.DenomTrace, error) {
 	transfers, err := transfertypes.NewQueryClient(ap).DenomTrace(ctx,
 		&transfertypes.QueryDenomTraceRequest{
 			Hash: denom,
 		})
 	if err != nil {
 		return nil, err
 	}
 	return transfers.DenomTrace, nil
 }
 func (ap *WasmProvider) QueryDenomTraces(ctx context.Context, offset, limit uint64, height int64) ([]transfertypes.DenomTrace, error) {
 	qc := transfertypes.NewQueryClient(ap)
 	p := DefaultPageRequest()
 	transfers := []transfertypes.DenomTrace{}
 	for {
 		res, err := qc.DenomTraces(ctx,
 			&transfertypes.QueryDenomTracesRequest{
 				Pagination: p,
 			})
 
 		if err != nil || res == nil {
 			return nil, err
 		}
 
 		transfers = append(transfers, res.DenomTraces...)
 		next := res.GetPagination().GetNextKey()
 		if len(next) == 0 {
 			break
 		}
 
 		time.Sleep(PaginationDelay)
 		p.Key = next
 	}
 	return transfers, nil
 }

relayer/chains/wasm/tx.go

@@ -63,7 +63,7 @@
 	defaultDelayPeriod = uint64(0)
 )
 
 func (ap *WasmProvider) TxFactory() tx.Factory {
 	return tx.Factory{}.
 		WithAccountRetriever(ap).
 		WithChainID(ap.PCfg.ChainID).
@@ -71,12 +71,12 @@
 		WithGasAdjustment(ap.PCfg.GasAdjustment).
 		WithGasPrices(ap.PCfg.GasPrices).
 		WithKeybase(ap.Keybase).
 		WithSignMode(ap.PCfg.SignMode()).
 		WithSimulateAndExecute(true)
 }
 
 // PrepareFactory mutates the tx factory with the appropriate account number, sequence number, and min gas settings.
 func (ap *WasmProvider) PrepareFactory(txf tx.Factory) (tx.Factory, error) {
 	var (
 		err      error
 		from     sdk.AccAddress
@@ -138,7 +138,7 @@
 	return txf, nil
 }
 
 func (pc *WasmProviderConfig) SignMode() signing.SignMode {
 	signMode := signing.SignMode_SIGN_MODE_UNSPECIFIED
 	switch pc.SignModeStr {
 	case "direct":
@@ -149,7 +149,7 @@
 	return signMode
 }
 
 func (ap *WasmProvider) NewClientState(dstChainID string, dstIBCHeader provider.IBCHeader, dstTrustingPeriod, dstUbdPeriod time.Duration, allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour bool) (ibcexported.ClientState, error) {
 
 	return &itm.ClientState{
 		ChainId:                      dstChainID,
@@ -163,7 +163,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) MsgCreateClient(clientState ibcexported.ClientState, consensusState ibcexported.ConsensusState) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -188,15 +188,15 @@
 	return ap.NewWasmContractMessage(MethodCreateClient, params)
 }
 
 func (ap *WasmProvider) MsgUpgradeClient(srcClientId string, consRes *clienttypes.QueryConsensusStateResponse, clientRes *clienttypes.QueryClientStateResponse) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) MsgSubmitMisbehaviour(clientID string, misbehaviour ibcexported.ClientMessage) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) ValidatePacket(msgTransfer provider.PacketInfo, latest provider.LatestBlock) error {
 
 	if msgTransfer.Sequence == 0 {
 		return errors.New("refusing to relay packet with sequence: 0")
@@ -226,7 +226,7 @@
 	return nil
 }
 
 func (ap *WasmProvider) PacketCommitment(ctx context.Context, msgTransfer provider.PacketInfo, height uint64) (provider.PacketProof, error) {
 	packetCommitmentResponse, err := ap.QueryPacketCommitment(
 		ctx, int64(height), msgTransfer.SourceChannel, msgTransfer.SourcePort, msgTransfer.Sequence,
 	)
@@ -240,7 +240,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) PacketAcknowledgement(ctx context.Context, msgRecvPacket provider.PacketInfo, height uint64) (provider.PacketProof, error) {
 	packetAckResponse, err := ap.QueryPacketAcknowledgement(ctx, int64(height), msgRecvPacket.SourceChannel, msgRecvPacket.SourcePort, msgRecvPacket.Sequence)
 	if err != nil {
 		return provider.PacketProof{}, nil
@@ -251,7 +251,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) PacketReceipt(ctx context.Context, msgTransfer provider.PacketInfo, height uint64) (provider.PacketProof, error) {
 
 	packetReceiptResponse, err := ap.QueryPacketReceipt(ctx, int64(height), msgTransfer.SourceChannel, msgTransfer.SourcePort, msgTransfer.Sequence)
 
@@ -264,7 +264,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) NextSeqRecv(ctx context.Context, msgTransfer provider.PacketInfo, height uint64) (provider.PacketProof, error) {
 	nextSeqRecvResponse, err := ap.QueryNextSeqRecv(ctx, int64(height), msgTransfer.DestChannel, msgTransfer.DestPort)
 	if err != nil {
 		return provider.PacketProof{}, nil
@@ -275,12 +275,12 @@
 	}, nil
 }
 
 func (ap *WasmProvider) MsgTransfer(dstAddr string, amount sdk.Coin, info provider.PacketInfo) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 	return nil, fmt.Errorf("Not implemented for Wasm")
 }
 
 func (ap *WasmProvider) MsgRecvPacket(msgTransfer provider.PacketInfo, proof provider.PacketProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -296,7 +296,7 @@
 	return ap.NewWasmContractMessage(MethodRecvPacket, params)
 }
 
 func (ap *WasmProvider) MsgAcknowledgement(msgRecvPacket provider.PacketInfo, proof provider.PacketProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -313,7 +313,7 @@
 
 }
 
 func (ap *WasmProvider) MsgTimeout(msgTransfer provider.PacketInfo, proof provider.PacketProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -330,18 +330,16 @@
 	return ap.NewWasmContractMessage(MethodTimeoutPacket, params)
 }
 
 func (ap *WasmProvider) MsgTimeoutRequest(msgTransfer provider.PacketInfo, proof provider.PacketProof) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
-	return nil, fmt.Errorf("MsgTimeoutRequest Not implemented for Wasm module")
 }
 
 // panic
 func (ap *WasmProvider) MsgTimeoutOnClose(msgTransfer provider.PacketInfo, proofUnreceived provider.PacketProof) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
-	return nil, nil
 }
 
 func (ap *WasmProvider) ConnectionHandshakeProof(ctx context.Context, msgOpenInit provider.ConnectionInfo, height uint64) (provider.ConnectionProof, error) {
 	clientState, clientStateProof, consensusStateProof, connStateProof, proofHeight, err := ap.GenerateConnHandshakeProof(ctx, int64(height), msgOpenInit.ClientID, msgOpenInit.ConnID)
 	if err != nil {
 		return provider.ConnectionProof{}, err
@@ -356,7 +354,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) ConnectionProof(ctx context.Context, msgOpenAck provider.ConnectionInfo, height uint64) (provider.ConnectionProof, error) {
 	connState, err := ap.QueryConnection(ctx, int64(height), msgOpenAck.ConnID)
 	if err != nil {
 		return provider.ConnectionProof{}, err
@@ -367,7 +365,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) MsgConnectionOpenInit(info provider.ConnectionInfo, proof provider.ConnectionProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -388,7 +386,7 @@
 
 }
 
 func (ap *WasmProvider) MsgConnectionOpenTry(msgOpenInit provider.ConnectionInfo, proof provider.ConnectionProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -423,7 +421,7 @@
 
 }
 
 func (ap *WasmProvider) MsgConnectionOpenAck(msgOpenTry provider.ConnectionInfo, proof provider.ConnectionProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -453,7 +451,7 @@
 	return ap.NewWasmContractMessage(MethodConnectionOpenAck, params)
 }
 
 func (ap *WasmProvider) MsgConnectionOpenConfirm(msgOpenAck provider.ConnectionInfo, proof provider.ConnectionProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -467,7 +465,7 @@
 	return ap.NewWasmContractMessage(MethodConnectionOpenConfirm, params)
 }
 
 func (ap *WasmProvider) ChannelProof(ctx context.Context, msg provider.ChannelInfo, height uint64) (provider.ChannelProof, error) {
 	channelResult, err := ap.QueryChannel(ctx, int64(height), msg.ChannelID, msg.PortID)
 	if err != nil {
 		return provider.ChannelProof{}, nil
@@ -483,7 +481,7 @@
 	}, nil
 }
 
 func (ap *WasmProvider) MsgChannelOpenInit(info provider.ChannelInfo, proof provider.ChannelProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -505,7 +503,7 @@
 	return ap.NewWasmContractMessage(MethodChannelOpenInit, params)
 }
 
 func (ap *WasmProvider) MsgChannelOpenTry(msgOpenInit provider.ChannelInfo, proof provider.ChannelProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -535,7 +533,7 @@
 	return ap.NewWasmContractMessage(MethodChannelOpenTry, params)
 }
 
 func (ap *WasmProvider) MsgChannelOpenAck(msgOpenTry provider.ChannelInfo, proof provider.ChannelProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -553,7 +551,7 @@
 	return ap.NewWasmContractMessage(MethodChannelOpenAck, params)
 }
 
 func (ap *WasmProvider) MsgChannelOpenConfirm(msgOpenAck provider.ChannelInfo, proof provider.ChannelProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -569,7 +567,7 @@
 	return ap.NewWasmContractMessage(MethodChannelOpenConfirm, params)
 }
 
 func (ap *WasmProvider) MsgChannelCloseInit(info provider.ChannelInfo, proof provider.ChannelProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -584,7 +582,7 @@
 	return ap.NewWasmContractMessage(MethodChannelCloseInit, params)
 }
 
 func (ap *WasmProvider) MsgChannelCloseConfirm(msgCloseInit provider.ChannelInfo, proof provider.ChannelProof) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -601,26 +599,26 @@
 	return ap.NewWasmContractMessage(MethodChannelCloseConfirm, params)
 }
 
 func (ap *WasmProvider) MsgUpdateClientHeader(latestHeader provider.IBCHeader, trustedHeight clienttypes.Height, trustedHeader provider.IBCHeader) (ibcexported.ClientMessage, error) {
 	trustedWasmHeader, ok := trustedHeader.(WasmIBCHeader)
 	if !ok {
 		return nil, fmt.Errorf("unsupported IBC trusted header type, expected: TendermintIBCHeader, actual: %T", trustedHeader)
 	}
 
 	latestWasmHeader, ok := latestHeader.(WasmIBCHeader)
 	if !ok {
 		return nil, fmt.Errorf("unsupported IBC header type, expected: TendermintIBCHeader, actual: %T", latestHeader)
 	}
 
 	return &itm.TmHeader{
 		SignedHeader:      latestWasmHeader.SignedHeader,
 		ValidatorSet:      latestWasmHeader.ValidatorSet,
 		TrustedValidators: trustedWasmHeader.ValidatorSet,
 		TrustedHeight:     int64(trustedHeight.RevisionHeight),
 	}, nil
 }
 
 func (ap *WasmProvider) MsgUpdateClient(clientID string, dstHeader ibcexported.ClientMessage) (provider.RelayerMessage, error) {
 	signer, err := ap.Address()
 	if err != nil {
 		return nil, err
@@ -640,27 +638,27 @@
 
 }
 
 func (ap *WasmProvider) QueryICQWithProof(ctx context.Context, msgType string, request []byte, height uint64) (provider.ICQProof, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) MsgSubmitQueryResponse(chainID string, queryID provider.ClientICQQueryID, proof provider.ICQProof) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) RelayPacketFromSequence(ctx context.Context, src provider.ChainProvider, srch, dsth, seq uint64, srcChanID, srcPortID string, order chantypes.Order) (provider.RelayerMessage, provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) AcknowledgementFromSequence(ctx context.Context, dst provider.ChainProvider, dsth, seq uint64, dstChanID, dstPortID, srcChanID, srcPortID string) (provider.RelayerMessage, error) {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) SendMessage(ctx context.Context, msg provider.RelayerMessage, memo string) (*provider.RelayerTxResponse, bool, error) {
 	return ap.SendMessages(ctx, []provider.RelayerMessage{msg}, memo)
 }
 
 func (ap *WasmProvider) SendMessages(ctx context.Context, msgs []provider.RelayerMessage, memo string) (*provider.RelayerTxResponse, bool, error) {
 	var (
 		rlyResp     *provider.RelayerTxResponse
 		callbackErr error
@@ -668,12 +666,12 @@
 	)
 
 	callback := func(rtr *provider.RelayerTxResponse, err error) {
 		callbackErr = err
 
 		if err != nil {
 			wg.Done()
 			return
 		}
 
 		for i, e := range rtr.Events {
 			if startsWithWasm(e.EventType) {
@@ -732,36 +730,36 @@
 
 	for _, msg := range msgs {
 		if msg == nil {
 			ap.log.Debug("One of the message of is nil ")
 			continue
 		}
 
 		wasmMsg, ok := msg.(*WasmContractMessage)
 		if !ok {
 			return fmt.Errorf("Wasm Message is not valid %s", wasmMsg.Type())
 		}
 
 		txBytes, sequence, err := ap.buildMessages(cliCtx, factory, wasmMsg.Msg)
 		if err != nil {
 			return err
 		}
 
 		if msg.Type() == MethodUpdateClient {
 			if err := ap.BroadcastTx(cliCtx, txBytes, []provider.RelayerMessage{msg}, asyncCtx, defaultBroadcastWaitTimeout, asyncCallback, true); err != nil {
 				if strings.Contains(err.Error(), sdkerrors.ErrWrongSequence.Error()) {
 					ap.handleAccountSequenceMismatchError(err)
 				}
 				return fmt.Errorf("Wasm: failed during updateClient %v", err)
 			}
 			ap.updateNextAccountSequence(sequence + 1)
 			continue
 		}
 		if err := ap.BroadcastTx(cliCtx, txBytes, []provider.RelayerMessage{msg}, asyncCtx, defaultBroadcastWaitTimeout, asyncCallback, false); err != nil {
 			if strings.Contains(err.Error(), sdkerrors.ErrWrongSequence.Error()) {
 				ap.handleAccountSequenceMismatchError(err)
 			}
 		}
 		ap.updateNextAccountSequence(sequence + 1)
 	}
 
 	//uncomment for saving msg
@@ -771,7 +769,7 @@
 
 }
 
 func (ap *WasmProvider) LogFailedTx(res *provider.RelayerTxResponse, err error, msgs []provider.RelayerMessage) {
 
 	fields := []zapcore.Field{zap.String("chain_id", ap.ChainId())}
 	// if res != nil {
@@ -784,7 +782,7 @@
 		// Make a copy since we may continue to the warning
 		errorFields := append(fields, zap.Error(err))
 		ap.log.Error(
 			"Failed sending wasm transaction",
 			errorFields...,
 		)
 
@@ -805,7 +803,7 @@
 }
 
 // LogSuccessTx take the transaction and the messages to create it and logs the appropriate data
 func (ap *WasmProvider) LogSuccessTx(res *sdk.TxResponse, msgs []provider.RelayerMessage) {
 	// Include the chain_id
 	fields := []zapcore.Field{zap.String("chain_id", ap.ChainId())}
 
@@ -869,7 +867,7 @@
 
 }
 
 func (ap *WasmProvider) sdkError(codespace string, code uint32) error {
 	// ABCIError will return an error other than "unknown" if syncRes.Code is a registered error in syncRes.Codespace
 	// This catches all of the sdk errors https://github.com/cosmos/cosmos-sdk/blob/f10f5e5974d2ecbf9efc05bc0bfe1c99fdeed4b6/types/errors/errors.go
 	err := errors.Unwrap(sdkerrors.ABCIError(codespace, code, "error broadcasting transaction"))
@@ -879,7 +877,7 @@
 	return nil
 }
 
 func (ap *WasmProvider) buildMessages(clientCtx client.Context, txf tx.Factory, msgs ...sdk.Msg) ([]byte, uint64, error) {
 	for _, msg := range msgs {
 		if err := msg.ValidateBasic(); err != nil {
 			return nil, 0, err
@@ -1013,8 +1011,7 @@
 	)
 
 	if shouldWait {
-		ap.waitForTx(asyncCtx, hexTx, msgs, asyncTimeout, asyncCallback)
-		return nil
+		return ap.waitForTx(asyncCtx, hexTx, msgs, asyncTimeout, asyncCallback)
 	}
 	go ap.waitForTx(asyncCtx, hexTx, msgs, asyncTimeout, asyncCallback)
 	return nil
@@ -1034,7 +1031,7 @@
 	asyncTimeout time.Duration, // timeout for waiting for block inclusion
 	asyncCallback func(*provider.RelayerTxResponse, error), // callback for success/fail of the wait for block inclusion
 ) error {
 	panic(fmt.Sprintf("%s%s", ap.ChainName(), NOT_IMPLEMENTED))
 }
 
 func (ap *WasmProvider) waitForTx(
@@ -1043,14 +1040,14 @@
 	msgs []provider.RelayerMessage, // used for logging only
 	waitTimeout time.Duration,
 	callback func(*provider.RelayerTxResponse, error),
-) {
+) error {
 	res, err := ap.waitForTxResult(ctx, txHash, waitTimeout)
 	if err != nil {
 		ap.log.Error("Failed to wait for block inclusion", zap.Error(err))
 		if callback != nil {
 			callback(nil, err)
 		}
-		return
+		return err
 	}
 
 	rlyResp := &provider.RelayerTxResponse{
@@ -1076,13 +1073,14 @@
 			callback(nil, err)
 		}
 		ap.LogFailedTx(rlyResp, nil, msgs)
-		return
+		return err
 	}
 
 	if callback != nil {
 		callback(rlyResp, nil)
 	}
 	ap.LogSuccessTx(res, msgs)
+	return nil
 }
 
 func (ap *WasmProvider) waitForTxResult(
@@ -1131,7 +1129,7 @@
 	AsAny() *codectypes.Any
 }
 
 func (ap *WasmProvider) mkTxResult(resTx *coretypes.ResultTx) (*sdk.TxResponse, error) {
 	txbz, err := ap.Cdc.TxConfig.TxDecoder()(resTx.Tx)
 	if err != nil {
 		return nil, err
@@ -1234,7 +1232,7 @@
 }
 
 // QueryABCI performs an ABCI query and returns the appropriate response and error sdk error code.
 func (cc *WasmProvider) QueryABCI(ctx context.Context, req abci.RequestQuery) (abci.ResponseQuery, error) {
 	opts := rpcclient.ABCIQueryOptions{
 		Height: req.Height,
 		Prove:  req.Prove,
@@ -1256,23 +1254,23 @@
 	return result.Response, nil
 }
 
 func (cc *WasmProvider) handleAccountSequenceMismatchError(err error) {
 
 	clientCtx := cc.ClientContext()
 	fmt.Println("client context is ", clientCtx.GetFromAddress())
 
 	_, seq, err := cc.ClientCtx.AccountRetriever.GetAccountNumberSequence(clientCtx, clientCtx.GetFromAddress())
 
 	// sequences := numRegex.FindAllString(err.Error(), -1)
 	// if len(sequences) != 2 {
 	// 	return
 	// }
 	// nextSeq, err := strconv.ParseUint(sequences[0], 10, 64)
 	if err != nil {
 		return
 	}
 
 	cc.nextAccountSeq = seq
 }
 
 func sdkErrorToGRPCError(resp abci.ResponseQuery) error {

relayer/chains/wasm/wasm_chain_processor.go

@@ -64,8 +64,8 @@
 	Header *types.LightBlock
 }
 
 func NewWasmChainProcessor(log *zap.Logger, provider *WasmProvider, metrics *processor.PrometheusMetrics) *WasmChainProcessor {
 	return &WasmChainProcessor{
 		log:                  log.With(zap.String("chain_name", provider.ChainName()), zap.String("chain_id", provider.ChainId())),
 		chainProvider:        provider,
 		latestClientState:    make(latestClientState),
@@ -92,7 +92,7 @@
 // latestClientState is a map of clientID to the latest clientInfo for that client.
 type latestClientState map[string]provider.ClientState
 
 func (l latestClientState) update(ctx context.Context, clientInfo clientInfo, ccp *WasmChainProcessor) {
 	existingClientInfo, ok := l[clientInfo.clientID]
 	var trustingPeriod time.Duration
 	if ok {
@@ -122,19 +122,19 @@
 }
 
 // Provider returns the ChainProvider, which provides the methods for querying, assembling IBC messages, and sending transactions.
 func (ccp *WasmChainProcessor) Provider() provider.ChainProvider {
 	return ccp.chainProvider
 }
 
 // Set the PathProcessors that this ChainProcessor should publish relevant IBC events to.
 // ChainProcessors need reference to their PathProcessors and vice-versa, handled by EventProcessorBuilder.Build().
 func (ccp *WasmChainProcessor) SetPathProcessors(pathProcessors processor.PathProcessors) {
 	ccp.pathProcessors = pathProcessors
 }
 
 // latestHeightWithRetry will query for the latest height, retrying in case of failure.
 // It will delay by latestHeightQueryRetryDelay between attempts, up to latestHeightQueryRetries.
 func (ccp *WasmChainProcessor) latestHeightWithRetry(ctx context.Context) (latestHeight int64, err error) {
 	return latestHeight, retry.Do(func() error {
 		latestHeightQueryCtx, cancelLatestHeightQueryCtx := context.WithTimeout(ctx, queryTimeout)
 		defer cancelLatestHeightQueryCtx()
@@ -153,7 +153,7 @@
 
 // nodeStatusWithRetry will query for the latest node status, retrying in case of failure.
 // It will delay by latestHeightQueryRetryDelay between attempts, up to latestHeightQueryRetries.
 func (ccp *WasmChainProcessor) nodeStatusWithRetry(ctx context.Context) (status *ctypes.ResultStatus, err error) {
 	return status, retry.Do(func() error {
 		latestHeightQueryCtx, cancelLatestHeightQueryCtx := context.WithTimeout(ctx, queryTimeout)
 		defer cancelLatestHeightQueryCtx()
@@ -172,7 +172,7 @@
 
 // clientState will return the most recent client state if client messages
 // have already been observed for the clientID, otherwise it will query for it.
 func (ccp *WasmChainProcessor) clientState(ctx context.Context, clientID string) (provider.ClientState, error) {
 	if state, ok := ccp.latestClientState[clientID]; ok && state.TrustingPeriod > 0 {
 		return state, nil
 	}
@@ -198,24 +198,24 @@
 	balanceUpdateWaitDuration time.Duration
 }
 
 func (ccp *WasmChainProcessor) StartFromHeight(ctx context.Context) int {
 	cfg := ccp.Provider().ProviderConfig().(*WasmProviderConfig)
 	if cfg.StartHeight != 0 {
 		return int(cfg.StartHeight)
 	}
 	snapshotHeight, err := common.LoadSnapshotHeight(ccp.Provider().ChainId())
 	if err != nil {
 		ccp.log.Warn("Failed to load height from snapshot", zap.Error(err))
 	} else {
 		ccp.log.Info("Obtained start height from config", zap.Int("height", snapshotHeight))
 	}
 	return snapshotHeight
 }
 
 // Run starts the query loop for the chain which will gather applicable ibc messages and push events out to the relevant PathProcessors.
 // The initialBlockHistory parameter determines how many historical blocks should be fetched and processed before continuing with current blocks.
 // ChainProcessors should obey the context and return upon context cancellation.
 func (ccp *WasmChainProcessor) Run(ctx context.Context, initialBlockHistory uint64) error {
 	// this will be used for persistence across query cycle loop executions
 	persistence := queryCyclePersistence{
 		minQueryLoopDuration:      defaultMinQueryLoopDuration,
@@ -242,30 +242,30 @@
 	}
 
 	// this will make initial QueryLoop iteration look back initialBlockHistory blocks in history
 	latestQueriedBlock := ccp.StartFromHeight(ctx)
 	if latestQueriedBlock < 0 {
 		latestQueriedBlock = int(persistence.latestHeight - int64(initialBlockHistory))
 		if latestQueriedBlock < 0 {
 			latestQueriedBlock = 0
 		}
 	}
 
 	persistence.latestQueriedBlock = int64(latestQueriedBlock)
 
 	ccp.log.Info("Start to query from height ", zap.Int("height", latestQueriedBlock))
 
 	_, lightBlock, err := ccp.chainProvider.QueryLightBlock(ctx, persistence.latestQueriedBlock)
 	if err != nil {
 		ccp.log.Error("Failed to get ibcHeader",
 			zap.Int64("height", persistence.latestQueriedBlock),
 			zap.Any("error", err),
 		)
 		return err
 	}
 
 	ccp.verifier = &Verifier{
 		Header: lightBlock,
 	}
 
 	var eg errgroup.Group
 	eg.Go(func() error {
@@ -278,7 +278,7 @@
 		return err
 	}
 
 	ccp.log.Debug("Entering Wasm main query loop")
 
 	ticker := time.NewTicker(persistence.minQueryLoopDuration)
 	defer ticker.Stop()
@@ -297,7 +297,7 @@
 }
 
 // initializeConnectionState will bootstrap the connectionStateCache with the open connection state.
 func (ccp *WasmChainProcessor) initializeConnectionState(ctx context.Context) error {
 	ctx, cancel := context.WithTimeout(ctx, queryTimeout)
 	defer cancel()
 	connections, err := ccp.chainProvider.QueryConnections(ctx)
@@ -317,7 +317,7 @@
 }
 
 // initializeChannelState will bootstrap the channelStateCache with the open channel state.
 func (ccp *WasmChainProcessor) initializeChannelState(ctx context.Context) error {
 	ctx, cancel := context.WithTimeout(ctx, queryTimeout)
 	defer cancel()
 	channels, err := ccp.chainProvider.QueryChannels(ctx)
@@ -340,14 +340,20 @@
 			CounterpartyChannelID: ch.Counterparty.ChannelId,
 			CounterpartyPortID:    ch.Counterparty.PortId,
 		}] = ch.State == chantypes.OPEN
+		ccp.log.Info("Found channel",
+			zap.String("channelID", ch.ChannelId),
+			zap.String("Port id ", ch.PortId))
+		zap.String("Counterparty Channel Id ", ch.Counterparty.ChannelId)
+		zap.String("Counterparty Port Id", ch.Counterparty.PortId)
+
 	}
 	return nil
 }
 
 func (ccp *WasmChainProcessor) queryCycle(ctx context.Context, persistence *queryCyclePersistence) error {
 	status, err := ccp.nodeStatusWithRetry(ctx)
 	if err != nil {
 		// don't want to cause WasmChainProcessor to quit here, can retry again next cycle.
 		ccp.log.Error(
 			"Failed to query node status after max attempts",
 			zap.Uint("attempts", latestHeightQueryRetries),
@@ -359,7 +365,7 @@
 	persistence.latestHeight = status.SyncInfo.LatestBlockHeight
 	// ccp.chainProvider.setCometVersion(ccp.log, status.NodeInfo.Version)
 
 	ccp.log.Info("Queried latest height",
 		zap.Int64("latest_height", persistence.latestHeight),
 	)
 
@@ -390,14 +396,14 @@
 
 	newLatestQueriedBlock := persistence.latestQueriedBlock
 	chainID := ccp.chainProvider.ChainId()
 	var latestHeader provider.IBCHeader
 
 	ccp.SnapshotHeight(int(persistence.latestHeight))
 
 	for i := persistence.latestQueriedBlock + 1; i <= persistence.latestHeight; i++ {
 		var eg errgroup.Group
 		var blockRes *ctypes.ResultBlockResults
 		var lightBlock *types.LightBlock
 		i := i
 		eg.Go(func() (err error) {
 			queryCtx, cancelQueryCtx := context.WithTimeout(ctx, blockResultsQueryTimeout)
@@ -409,7 +415,7 @@
 		eg.Go(func() (err error) {
 			queryCtx, cancelQueryCtx := context.WithTimeout(ctx, queryTimeout)
 			defer cancelQueryCtx()
 			latestHeader, lightBlock, err = ccp.chainProvider.QueryLightBlock(queryCtx, i)
 			return err
 		})
 
@@ -418,13 +424,13 @@
 			break
 		}
 
 		if err := ccp.Verify(ctx, lightBlock); err != nil {
 			ccp.log.Error("failed to Verify Wasm Header", zap.Int64("Height", blockRes.Height))
 			return err
 		}
 
 		ccp.log.Debug("Verified block ",
 			zap.Int64("height", lightBlock.Header.Height))
 
 		heightUint64 := uint64(i)
 
@@ -495,23 +501,23 @@
 	return nil
 }
 
 func (ccp *WasmChainProcessor) SnapshotHeight(height int) {
 
 	blockInterval := ccp.Provider().ProviderConfig().GetBlockInterval()
 	snapshotThreshold := common.ONE_HOUR / int(blockInterval)
 
 	retryAfter := ccp.Provider().ProviderConfig().GetFirstRetryBlockAfter()
 	snapshotHeight := height - int(retryAfter)
 
 	if snapshotHeight%snapshotThreshold == 0 {
 		err := common.SnapshotHeight(ccp.Provider().ChainId(), height)
 		if err != nil {
 			ccp.log.Warn("Failed saving height snapshot for height", zap.Int("height", height))
 		}
 	}
 }
 
 func (ccp *WasmChainProcessor) CollectMetrics(ctx context.Context, persistence *queryCyclePersistence) {
 	ccp.CurrentBlockHeight(ctx, persistence)
 
 	// Wait a while before updating the balance
@@ -521,47 +527,47 @@
 	}
 }
 
 func (ccp *WasmChainProcessor) CurrentBlockHeight(ctx context.Context, persistence *queryCyclePersistence) {
 	ccp.metrics.SetLatestHeight(ccp.chainProvider.ChainId(), persistence.latestHeight)
 }
 
 func (ccp *WasmChainProcessor) Verify(ctx context.Context, untrusted *types.LightBlock) error {
 
 	if untrusted.Height != ccp.verifier.Header.Height+1 {
 		return errors.New("headers must be adjacent in height")
 	}
 
 	if err := verifyNewHeaderAndVals(untrusted.SignedHeader,
 		untrusted.ValidatorSet,
 		ccp.verifier.Header.SignedHeader,
 		time.Now(), 0); err != nil {
 		return fmt.Errorf("Failed to verify Header: %v", err)
 	}
 
 	if !bytes.Equal(untrusted.Header.ValidatorsHash, ccp.verifier.Header.NextValidatorsHash) {
 		err := fmt.Errorf("expected old header next validators (%X) to match those from new header (%X)",
 			ccp.verifier.Header.NextValidatorsHash,
 			untrusted.Header.ValidatorsHash,
 		)
 		return err
 	}
 
 	if !bytes.Equal(untrusted.Header.LastBlockID.Hash.Bytes(), ccp.verifier.Header.Commit.BlockID.Hash.Bytes()) {
 		err := fmt.Errorf("expected LastBlockId Hash (%X) of current header  to match those from trusted Header BlockID hash (%X)",
 			ccp.verifier.Header.NextValidatorsHash,
 			untrusted.Header.ValidatorsHash,
 		)
 		return err
 	}
 
 	// Ensure that +2/3 of new validators signed correctly.
 	if err := untrusted.ValidatorSet.VerifyCommitLight(ccp.verifier.Header.ChainID, untrusted.Commit.BlockID,
 		untrusted.Header.Height, untrusted.Commit); err != nil {
 		return fmt.Errorf("invalid header: %v", err)
 	}
 
 	ccp.verifier.Header = untrusted
 	return nil
 
 }
 
@@ -570,40 +576,40 @@
 	untrustedVals *types.ValidatorSet,
 	trustedHeader *types.SignedHeader,
 	now time.Time,
 	maxClockDrift time.Duration) error {
 
 	if err := untrustedHeader.ValidateBasic(trustedHeader.ChainID); err != nil {
 		return fmt.Errorf("untrustedHeader.ValidateBasic failed: %w", err)
 	}
 
 	if untrustedHeader.Height <= trustedHeader.Height {
 		return fmt.Errorf("expected new header height %d to be greater than one of old header %d",
 			untrustedHeader.Height,
 			trustedHeader.Height)
 	}
 
 	if !untrustedHeader.Time.After(trustedHeader.Time) {
 		return fmt.Errorf("expected new header time %v to be after old header time %v",
 			untrustedHeader.Time,
 			trustedHeader.Time)
 	}
 
 	if !untrustedHeader.Time.Before(now.Add(maxClockDrift)) {
 		return fmt.Errorf("new header has a time from the future %v (now: %v; max clock drift: %v)",
 			untrustedHeader.Time,
 			now,
 			maxClockDrift)
 	}
 
 	if !bytes.Equal(untrustedHeader.ValidatorsHash, untrustedVals.Hash()) {
 		return fmt.Errorf("expected new header validators (%X) to match those that were supplied (%X) at height %d",
 			untrustedHeader.ValidatorsHash,
 			untrustedVals.Hash(),
 			untrustedHeader.Height,
 		)
 	}
 
 	return nil
 }
 
 // func (ccp *WasmChainProcessor) CurrentRelayerBalance(ctx context.Context) {

relayer/common/const.go

@@ -4,8 +4,11 @@ var (
 	EventTimeoutRequest   = "TimeoutRequest(bytes)"
 	IconModule            = "icon"
 	WasmModule            = "wasm"
-	TendermintLightClient = "tendermint"
+	ArchwayModule         = "archway"
+	TendermintLightClient = "07-tendermint"
 	IconLightClient       = "iconclient"
+	ConnectionKey         = "connection"
+	ChannelKey            = "channel"
 	ONE_HOUR              = 60 * 60 * 1000
-	NanosecondRatio       = 1000_000
+	NanosecondRatio 	  = 1000_000
 )

relayer/common/identifier.go

@@ -0,0 +1,7 @@
+package common
+
+import "fmt"
+
+func GetIdentifier(name string, i int) string {
+	return fmt.Sprintf("%s-%d", name, i)
+}

relayer/processor/message_processor.go

@@ -83,7 +83,6 @@
 	src, dst *pathEndRuntime,
 ) error {
 
-	fmt.Println("inside process Messages")
 	// 2/3 rule enough_time_pass && context change in case of BTPBlock
 	needsClientUpdate, err := mp.shouldUpdateClientNow(ctx, src, dst)
 	if err != nil {
@@ -105,18 +104,18 @@
 // Otherwise, it will be attempted if either 2/3 of the trusting period
 // or the configured client update threshold duration has passed.
 func (mp *messageProcessor) shouldUpdateClientNow(ctx context.Context, src, dst *pathEndRuntime) (bool, error) {
 	var err error
 	// handle if dst is IconLightClient
 	if ClientIsIcon(dst.clientState) {
 		header, found := nextIconIBCHeader(src.ibcHeaderCache.Clone(), dst.lastClientUpdateHeight)
 		if !found {
 			header, err = src.chainProvider.QueryIBCHeader(ctx, int64(src.latestBlock.Height))
 			if err != nil {
 				return false, err
 			}
 			if !header.IsCompleteBlock() {
 				return false, nil
 			}
 		}
 		if header.ShouldUpdateWithZeroMessage() {
 			return true, nil

relayer/processor/path_end_runtime.go

@@ -492,9 +492,9 @@
 			// this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet.
 			return false
 		}
 		if inProgress.retryCount <= 1 && blocksSinceLastProcessed < pathEnd.chainProvider.ProviderConfig().GetFirstRetryBlockAfter() {
 			return false
 		}
 	} else {
 		if blocksSinceLastProcessed < blocksToRetryAssemblyAfter {
 			// this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet.
@@ -532,18 +532,26 @@
 	case chantypes.EventTypeRecvPacket:
 		toDelete[eventType] = []uint64{sequence}
 		toDeleteCounterparty[chantypes.EventTypeSendPacket] = []uint64{sequence}
+	case chantypes.EventTypeWriteAck:
+		toDelete[eventType] = []uint64{sequence}
+	case common.EventTimeoutRequest:
+		toDelete[eventType] = []uint64{sequence}
+		toDeleteCounterparty[chantypes.EventTypeSendPacket] = []uint64{sequence}
 	case chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket, chantypes.EventTypeTimeoutPacketOnClose:
 		toDelete[eventType] = []uint64{sequence}
 		toDeleteCounterparty[chantypes.EventTypeRecvPacket] = []uint64{sequence}
+		toDeleteCounterparty[chantypes.EventTypeWriteAck] = []uint64{sequence}
+		toDelete[chantypes.EventTypeAcknowledgePacket] = []uint64{sequence}
 		toDelete[chantypes.EventTypeSendPacket] = []uint64{sequence}
+		toDeleteCounterparty[common.EventTimeoutRequest] = []uint64{sequence}
 	}
 	// delete in progress send for this specific message
 	pathEnd.packetProcessing[k].deleteMessages(map[string][]uint64{
 		eventType: {sequence},
 	})
 	// delete all packet flow retention history for this sequence
 	pathEnd.messageCache.PacketFlow[k].DeleteMessages(toDelete)
-	counterparty.messageCache.PacketFlow[k].DeleteMessages(toDeleteCounterparty)
+	counterparty.messageCache.PacketFlow[k.Counterparty()].DeleteMessages(toDeleteCounterparty)
 }
 
 // shouldSendConnectionMessage determines if the connection handshake message should be sent now.
@@ -580,9 +588,9 @@
 			// this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet.
 			return false
 		}
 		if inProgress.retryCount <= 1 && blocksSinceLastProcessed < pathEnd.chainProvider.ProviderConfig().GetFirstRetryBlockAfter() {
 			return false
 		}
 	} else {
 		if blocksSinceLastProcessed < blocksToRetryAssemblyAfter {
 			// this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet.
@@ -660,9 +668,9 @@
 			// this message was sent less than blocksToRetrySendAfter ago, do not attempt to send again yet.
 			return false
 		}
 		if inProgress.retryCount <= 1 && blocksSinceLastProcessed < pathEnd.chainProvider.ProviderConfig().GetFirstRetryBlockAfter() {
 			return false
 		}
 	} else {
 		if blocksSinceLastProcessed < blocksToRetryAssemblyAfter {
 			// this message was sent less than blocksToRetryAssemblyAfter ago, do not attempt assembly again yet.

relayer/processor/path_processor_internal.go

@@ -209,18 +209,9 @@
 	for seq, info := range pathEndPacketFlowMessages.DstMsgRecvPacket {
 		deletePreInitIfMatches(info)
 		toDeleteSrc[chantypes.EventTypeSendPacket] = append(toDeleteSrc[chantypes.EventTypeSendPacket], seq)
+		toDeleteDst[chantypes.EventTypeRecvPacket] = append(toDeleteDst[chantypes.EventTypeRecvPacket], seq)
+
 	}
-	// 	if len(info.Ack) == 0 {
-	// 		// have recv_packet but not write_acknowledgement yet. skip for now.
-	// 		continue
-	// 	}
-	// 	// msg is received by dst chain, but no ack yet. Need to relay ack from dst to src!
-	// 	ackMsg := packetIBCMessage{
-	// 		eventType: chantypes.EventTypeAcknowledgePacket,
-	// 		info:      info,
-	// 	}
-	// 	msgs = append(msgs, ackMsg)
-	// }
 
 	processRemovals()
 
@@ -234,7 +225,6 @@
 
 	for seq, msgTimeoutRequest := range pathEndPacketFlowMessages.DstMsgRequestTimeout {
 		toDeleteSrc[chantypes.EventTypeSendPacket] = append(toDeleteSrc[chantypes.EventTypeSendPacket], seq)
-		toDeleteDst[common.EventTimeoutRequest] = append(toDeleteDst[common.EventTimeoutRequest], seq)
 		timeoutMsg := packetIBCMessage{
 			eventType: chantypes.EventTypeTimeoutPacket,
 			info:      msgTimeoutRequest,
@@ -1000,28 +990,6 @@
 	pathEnd2ProcessRes := make([]pathEndPacketFlowResponse, len(channelPairs))
 
 	for i, pair := range channelPairs {
-		// Append acks into recv packet info if present
-		// pathEnd1DstMsgRecvPacket :=
-		// for seq, ackInfo := range pp.pathEnd2.messageCache.PacketFlow[pair.pathEnd2ChannelKey][chantypes.EventTypeWriteAck] {
-		// 	if recvPacketInfo, ok := pathEnd1DstMsgRecvPacket[seq]; ok {
-		// 		recvPacketInfo.Ack = ackInfo.Ack
-		// 		pathEnd1DstMsgRecvPacket[seq] = recvPacketInfo
-		// 		continue
-		// 	}
-		// 	pathEnd1DstMsgRecvPacket[seq] = ackInfo
-
-		// }
-
-		// pathEnd2DstMsgRecvPacket := pp.pathEnd1.messageCache.PacketFlow[pair.pathEnd1ChannelKey][chantypes.EventTypeRecvPacket]
-		// for seq, ackInfo := range pp.pathEnd1.messageCache.PacketFlow[pair.pathEnd1ChannelKey][chantypes.EventTypeWriteAck] {
-		// 	if recvPacketInfo, ok := pathEnd2DstMsgRecvPacket[seq]; ok {
-		// 		recvPacketInfo.Ack = ackInfo.Ack
-		// 		pathEnd2DstMsgRecvPacket[seq] = recvPacketInfo
-		// 		continue
-		// 	}
-
-		// 	pathEnd2DstMsgRecvPacket[seq] = ackInfo
-		// }
 
 		pathEnd1PacketFlowMessages := pathEndPacketFlowMessages{
 			Src:                              pp.pathEnd1,

relayer/processor/types.go

@@ -565,9 +565,9 @@
 // PacketInfoChannelKey returns the applicable ChannelKey for the chain based on the eventType.
 func PacketInfoChannelKey(eventType string, info provider.PacketInfo) (ChannelKey, error) {
 	switch eventType {
-	case chantypes.EventTypeRecvPacket, chantypes.EventTypeWriteAck:
+	case chantypes.EventTypeRecvPacket, chantypes.EventTypeWriteAck, common.EventTimeoutRequest:
 		return packetInfoChannelKey(info).Counterparty(), nil
-	case chantypes.EventTypeSendPacket, chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket, chantypes.EventTypeTimeoutPacketOnClose, common.EventTimeoutRequest:
+	case chantypes.EventTypeSendPacket, chantypes.EventTypeAcknowledgePacket, chantypes.EventTypeTimeoutPacket, chantypes.EventTypeTimeoutPacketOnClose:
 		return packetInfoChannelKey(info), nil
 	}
 	return ChannelKey{}, fmt.Errorf("eventType not expected for packetIBCMessage channelKey: %s", eventType)