fix: wasm next seq recv type conversion method

relayer/chains/wasm/query.go

@@ -316,44 +316,44 @@
 }
 
 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()
 	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) QueryIBCHandlerContractProcessed(ctx context.Context, param wasmtypes.RawContractMessage) ([]byte, error) {
@@ -506,8 +506,8 @@
 }
 
 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
@@ -732,14 +732,18 @@
 	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 {
 		return nil, err
 	}
 
 	return &chantypes.QueryNextSequenceReceiveResponse{
-		NextSequenceReceive: sdk.BigEndianToUint64(nextSeqRecv.Data.Bytes()),
+		NextSequenceReceive: seq,
 		Proof:               proof,
 		ProofHeight:         clienttypes.NewHeight(0, uint64(height)),
 	}, nil
@@ -860,22 +864,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
 }