chore: remove retry on getChannels for initializeChannelCache

relayer/chains/wasm/query.go

@@ -272,7 +272,7 @@
 
 	iconClientState, ok := clientS.(*icon.ClientState)
 	if !ok {
-		return nil, fmt.Errorf("Error casting to icon.ClientState")
+		return nil, fmt.Errorf("error casting to icon.ClientState")
 	}
 
 	return iconClientState, nil
@@ -297,13 +297,13 @@
 	return &connS, nil
 }
 
-func (ap *WasmProvider) QueryChannelContract(ctx context.Context, portId, channelId string) (*chantypes.Channel, error) {
+func (ap *WasmProvider) QueryChannelContractNoRetry(ctx context.Context, portId, channelId string) (*chantypes.Channel, error) {
 	channelStateParam, err := types.NewChannel(portId, channelId).Bytes()
 	if err != nil {
 		return nil, err
 	}
 
-	channelState, err := ap.QueryIBCHandlerContractProcessed(ctx, channelStateParam)
+	channelState, err := ap.QueryIBCHandlerContractNoRetry(ctx, channelStateParam)
 	if err != nil {
 		return nil, err
 	}
@@ -316,46 +316,67 @@
 }
 
 func (ap *WasmProvider) QueryClientConsensusState(ctx context.Context, chainHeight int64, clientid string, clientHeight ibcexported.Height) (*clienttypes.QueryConsensusStateResponse, error) {
 
 	consensusStateParam, err := types.NewConsensusStateByHeight(clientid, uint64(clientHeight.GetRevisionHeight())).Bytes()
+	if err != nil {
+		return nil, err
+	}
 	consensusState, err := ap.QueryIBCHandlerContractProcessed(ctx, consensusStateParam)
 	if err != nil {
 		return nil, err
 	}
 
 	cdc := codec.NewProtoCodec(ap.Cdc.InterfaceRegistry)
 	csState, err := clienttypes.UnmarshalConsensusState(cdc, consensusState)
 	if err != nil {
 		return nil, err
 	}
 
 	anyConsensusState, err := clienttypes.PackConsensusState(csState)
 	if err != nil {
 		return nil, err
 	}
 	return clienttypes.NewQueryConsensusStateResponse(anyConsensusState, nil, clienttypes.NewHeight(0, uint64(chainHeight))), nil
 }
 
 func (ap *WasmProvider) QueryIBCHandlerContract(ctx context.Context, param wasmtypes.RawContractMessage) (op *wasmtypes.QuerySmartContractStateResponse, err error) {
 	return op, retry.Do(func() error {
 		done := ap.SetSDKContext()
 		defer done()
 		op, err = ap.QueryClient.SmartContractState(ctx, &wasmtypes.QuerySmartContractStateRequest{
 			Address:   ap.PCfg.IbcHandlerAddress,
 			QueryData: param,
 		})
 		return err
 	}, retry.Context(ctx), retry.Attempts(latestHeightQueryRetries), retry.Delay(50*time.Millisecond), retry.LastErrorOnly(true), retry.OnRetry(func(n uint, err error) {
 		ap.log.Error(
 			"Failed to query",
 			zap.Uint("attempt", n+1),
 			zap.Uint("max_attempts", latestHeightQueryRetries),
 			zap.Any("Param", param),
 			zap.Error(err),
 		)
 	}))
 }
 
+func (ap *WasmProvider) QueryIBCHandlerContractNoRetry(ctx context.Context, param wasmtypes.RawContractMessage) ([]byte, error) {
+	done := ap.SetSDKContext()
+	defer done()
+	resp, err := ap.QueryClient.SmartContractState(ctx, &wasmtypes.QuerySmartContractStateRequest{
+		Address:   ap.PCfg.IbcHandlerAddress,
+		QueryData: param,
+	})
+	if err != nil {
+		ap.log.Error(
+			"Failed to query",
+			zap.Any("Param", param),
+			zap.Error(err),
+		)
+		return nil, err
+	}
+	return ProcessContractResponse(resp)
+}
+
 func (ap *WasmProvider) QueryIBCHandlerContractProcessed(ctx context.Context, param wasmtypes.RawContractMessage) ([]byte, error) {
 	res, err := ap.QueryIBCHandlerContract(ctx, param)
 	if err != nil {
@@ -501,13 +522,16 @@
 
 	storageKey := getStorageKeyFromPath(common.GetConnectionCommitmentKey(connectionid))
 	connProof, err := ap.QueryWasmProof(ctx, storageKey, height)
+	if err != nil {
+		return nil, err
+	}
 
 	return conntypes.NewQueryConnectionResponse(conn, connProof, clienttypes.NewHeight(0, uint64(height))), nil
 }
 
 func (ap *WasmProvider) QueryWasmProof(ctx context.Context, storageKey []byte, height int64) ([]byte, error) {
 	done := ap.SetSDKContext()
 	defer done()
 	ibcAddr, err := sdk.AccAddressFromBech32(ap.PCfg.IbcHandlerAddress)
 	if err != nil {
 		return nil, err
@@ -522,7 +546,7 @@
 	}
 
 	req := abci.RequestQuery{
-		Path:   fmt.Sprintf("store/wasm/key"),
+		Path:   "store/wasm/key",
 		Data:   key,
 		Prove:  true,
 		Height: height,
@@ -643,6 +667,9 @@
 
 	storageKey := getStorageKeyFromPath(common.GetChannelCommitmentKey(portid, channelid))
 	proof, err := ap.QueryWasmProof(ctx, storageKey, height)
+	if err != nil {
+		return nil, err
+	}
 
 	return chantypes.NewQueryChannelResponse(channelS, proof, clienttypes.NewHeight(0, uint64(height))), nil
 }
@@ -683,7 +710,7 @@
 	for i := 0; i <= int(nextSeq)-1; i++ {
 		for _, portId := range allPorts {
 			channelId := common.GetIdentifier(common.ChannelKey, i)
-			channel, err := ap.QueryChannelContract(ctx, portId, channelId)
+			channel, err := ap.QueryChannelContractNoRetry(ctx, portId, channelId)
 			if err != nil {
 				continue
 			}
@@ -732,10 +759,10 @@
 	if err != nil {
 		return nil, err
 	}
 	var seq uint64
 	if err := json.Unmarshal(nextSeqRecv.Data, &seq); err != nil {
 		return nil, err
 	}
 
 	proof, err := ap.QueryWasmProof(ctx, common.MustHexStrToBytes(STORAGEKEY__NextSequenceReceive), height)
 	if err != nil {
@@ -743,7 +770,7 @@
 	}
 
 	return &chantypes.QueryNextSequenceReceiveResponse{
 		NextSequenceReceive: seq,
 		Proof:               proof,
 		ProofHeight:         clienttypes.NewHeight(0, uint64(height)),
 	}, nil
@@ -864,22 +891,22 @@
 	return transfers, nil
 }
 
 func (ap *WasmProvider) QueryClientPrevConsensusStateHeight(ctx context.Context, chainHeight int64, clientId string, clientHeight int64) (exported.Height, error) {
 	param, err := types.NewPrevConsensusStateHeight(clientId, uint64(clientHeight)).Bytes()
 	res, err := ap.QueryIBCHandlerContract(ctx, param)
 	if err != nil {
 		return nil, err
 	}
 
 	var heights []int64
 	err = json.Unmarshal(res.Data.Bytes(), &heights)
 
 	if err != nil {
 		return nil, err
 	}
 
 	if len(heights) == 0 {
 		return nil, fmt.Errorf("consensus state of client %s before %d", clientId, clientHeight)
 	}
 	return clienttypes.Height{RevisionNumber: 0, RevisionHeight: uint64(heights[0])}, nil
 }

relayer/chains/wasm/utils.go

@@ -3,9 +3,9 @@
 import (
 	"encoding/binary"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"strconv"
-	"strings"
 
 	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
 	"github.com/cosmos/relayer/v2/relayer/common"
@@ -30,9 +30,11 @@
 }
 
 func ProcessContractResponse(p *wasmtypes.QuerySmartContractStateResponse) ([]byte, error) {
-	data := string(p.Data.Bytes())
-	trimmedData := strings.ReplaceAll(data, `"`, "")
-	return hex.DecodeString(trimmedData)
+	var output string
+	if err := json.Unmarshal(p.Data.Bytes(), &output); err != nil {
+		return nil, err
+	}
+	return hex.DecodeString(output)
 }
 
 func getStorageKeyFromPath(path []byte) []byte {