@xpla/xpla-react 1.7.0-beta.0

package/src/ibc/lightclients/wasm/v1/wasm.ts

@@ -0,0 +1,438 @@
+import { Height, HeightAmino } from "../../../core/client/v1/client";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial, bytesFromBase64, base64FromBytes } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** Wasm light client's Client state */
+export interface ClientState {
+  /**
+   * bytes encoding the client state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data: Uint8Array;
+  checksum: Uint8Array;
+  latestHeight: Height;
+}
+export interface ClientStateProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientState";
+  value: Uint8Array;
+}
+/** Wasm light client's Client state */
+export interface ClientStateAmino {
+  /**
+   * bytes encoding the client state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data: string;
+  checksum: string;
+  latest_height: HeightAmino;
+}
+export interface ClientStateAminoMsg {
+  type: "cosmos-sdk/ClientState";
+  value: ClientStateAmino;
+}
+/** Wasm light client's ConsensusState */
+export interface ConsensusState {
+  /**
+   * bytes encoding the consensus state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data: Uint8Array;
+}
+export interface ConsensusStateProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState";
+  value: Uint8Array;
+}
+/** Wasm light client's ConsensusState */
+export interface ConsensusStateAmino {
+  /**
+   * bytes encoding the consensus state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data: string;
+}
+export interface ConsensusStateAminoMsg {
+  type: "cosmos-sdk/ConsensusState";
+  value: ConsensusStateAmino;
+}
+/** Wasm light client message (either header(s) or misbehaviour) */
+export interface ClientMessage {
+  data: Uint8Array;
+}
+export interface ClientMessageProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage";
+  value: Uint8Array;
+}
+/** Wasm light client message (either header(s) or misbehaviour) */
+export interface ClientMessageAmino {
+  data: string;
+}
+export interface ClientMessageAminoMsg {
+  type: "cosmos-sdk/ClientMessage";
+  value: ClientMessageAmino;
+}
+/**
+ * Checksums defines a list of all checksums that are stored
+ * 
+ * Deprecated: This message is deprecated in favor of storing the checksums
+ * using a Collections.KeySet.
+ */
+/** @deprecated */
+export interface Checksums {
+  checksums: Uint8Array[];
+}
+export interface ChecksumsProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.Checksums";
+  value: Uint8Array;
+}
+/**
+ * Checksums defines a list of all checksums that are stored
+ * 
+ * Deprecated: This message is deprecated in favor of storing the checksums
+ * using a Collections.KeySet.
+ */
+/** @deprecated */
+export interface ChecksumsAmino {
+  checksums: string[];
+}
+export interface ChecksumsAminoMsg {
+  type: "cosmos-sdk/Checksums";
+  value: ChecksumsAmino;
+}
+function createBaseClientState(): ClientState {
+  return {
+    data: new Uint8Array(),
+    checksum: new Uint8Array(),
+    latestHeight: Height.fromPartial({})
+  };
+}
+export const ClientState = {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientState",
+  aminoType: "cosmos-sdk/ClientState",
+  is(o: any): o is ClientState {
+    return o && (o.$typeUrl === ClientState.typeUrl || (o.data instanceof Uint8Array || typeof o.data === "string") && (o.checksum instanceof Uint8Array || typeof o.checksum === "string") && Height.is(o.latestHeight));
+  },
+  isAmino(o: any): o is ClientStateAmino {
+    return o && (o.$typeUrl === ClientState.typeUrl || (o.data instanceof Uint8Array || typeof o.data === "string") && (o.checksum instanceof Uint8Array || typeof o.checksum === "string") && Height.isAmino(o.latest_height));
+  },
+  encode(message: ClientState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    if (message.checksum.length !== 0) {
+      writer.uint32(18).bytes(message.checksum);
+    }
+    if (message.latestHeight !== undefined) {
+      Height.encode(message.latestHeight, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ClientState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClientState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        case 2:
+          message.checksum = reader.bytes();
+          break;
+        case 3:
+          message.latestHeight = Height.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<ClientState>): ClientState {
+    const message = createBaseClientState();
+    message.data = object.data ?? new Uint8Array();
+    message.checksum = object.checksum ?? new Uint8Array();
+    message.latestHeight = object.latestHeight !== undefined && object.latestHeight !== null ? Height.fromPartial(object.latestHeight) : undefined;
+    return message;
+  },
+  fromAmino(object: ClientStateAmino): ClientState {
+    const message = createBaseClientState();
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    if (object.checksum !== undefined && object.checksum !== null) {
+      message.checksum = bytesFromBase64(object.checksum);
+    }
+    if (object.latest_height !== undefined && object.latest_height !== null) {
+      message.latestHeight = Height.fromAmino(object.latest_height);
+    }
+    return message;
+  },
+  toAmino(message: ClientState): ClientStateAmino {
+    const obj: any = {};
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    obj.checksum = message.checksum ? base64FromBytes(message.checksum) : undefined;
+    obj.latest_height = message.latestHeight ? Height.toAmino(message.latestHeight) : {};
+    return obj;
+  },
+  fromAminoMsg(object: ClientStateAminoMsg): ClientState {
+    return ClientState.fromAmino(object.value);
+  },
+  toAminoMsg(message: ClientState): ClientStateAminoMsg {
+    return {
+      type: "cosmos-sdk/ClientState",
+      value: ClientState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ClientStateProtoMsg): ClientState {
+    return ClientState.decode(message.value);
+  },
+  toProto(message: ClientState): Uint8Array {
+    return ClientState.encode(message).finish();
+  },
+  toProtoMsg(message: ClientState): ClientStateProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.ClientState",
+      value: ClientState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ClientState.typeUrl, ClientState);
+GlobalDecoderRegistry.registerAminoProtoMapping(ClientState.aminoType, ClientState.typeUrl);
+function createBaseConsensusState(): ConsensusState {
+  return {
+    data: new Uint8Array()
+  };
+}
+export const ConsensusState = {
+  typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState",
+  aminoType: "cosmos-sdk/ConsensusState",
+  is(o: any): o is ConsensusState {
+    return o && (o.$typeUrl === ConsensusState.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
+  },
+  isAmino(o: any): o is ConsensusStateAmino {
+    return o && (o.$typeUrl === ConsensusState.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
+  },
+  encode(message: ConsensusState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ConsensusState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsensusState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<ConsensusState>): ConsensusState {
+    const message = createBaseConsensusState();
+    message.data = object.data ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: ConsensusStateAmino): ConsensusState {
+    const message = createBaseConsensusState();
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    return message;
+  },
+  toAmino(message: ConsensusState): ConsensusStateAmino {
+    const obj: any = {};
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ConsensusStateAminoMsg): ConsensusState {
+    return ConsensusState.fromAmino(object.value);
+  },
+  toAminoMsg(message: ConsensusState): ConsensusStateAminoMsg {
+    return {
+      type: "cosmos-sdk/ConsensusState",
+      value: ConsensusState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ConsensusStateProtoMsg): ConsensusState {
+    return ConsensusState.decode(message.value);
+  },
+  toProto(message: ConsensusState): Uint8Array {
+    return ConsensusState.encode(message).finish();
+  },
+  toProtoMsg(message: ConsensusState): ConsensusStateProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState",
+      value: ConsensusState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ConsensusState.typeUrl, ConsensusState);
+GlobalDecoderRegistry.registerAminoProtoMapping(ConsensusState.aminoType, ConsensusState.typeUrl);
+function createBaseClientMessage(): ClientMessage {
+  return {
+    data: new Uint8Array()
+  };
+}
+export const ClientMessage = {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage",
+  aminoType: "cosmos-sdk/ClientMessage",
+  is(o: any): o is ClientMessage {
+    return o && (o.$typeUrl === ClientMessage.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
+  },
+  isAmino(o: any): o is ClientMessageAmino {
+    return o && (o.$typeUrl === ClientMessage.typeUrl || o.data instanceof Uint8Array || typeof o.data === "string");
+  },
+  encode(message: ClientMessage, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ClientMessage {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClientMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<ClientMessage>): ClientMessage {
+    const message = createBaseClientMessage();
+    message.data = object.data ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: ClientMessageAmino): ClientMessage {
+    const message = createBaseClientMessage();
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    return message;
+  },
+  toAmino(message: ClientMessage): ClientMessageAmino {
+    const obj: any = {};
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ClientMessageAminoMsg): ClientMessage {
+    return ClientMessage.fromAmino(object.value);
+  },
+  toAminoMsg(message: ClientMessage): ClientMessageAminoMsg {
+    return {
+      type: "cosmos-sdk/ClientMessage",
+      value: ClientMessage.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ClientMessageProtoMsg): ClientMessage {
+    return ClientMessage.decode(message.value);
+  },
+  toProto(message: ClientMessage): Uint8Array {
+    return ClientMessage.encode(message).finish();
+  },
+  toProtoMsg(message: ClientMessage): ClientMessageProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage",
+      value: ClientMessage.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ClientMessage.typeUrl, ClientMessage);
+GlobalDecoderRegistry.registerAminoProtoMapping(ClientMessage.aminoType, ClientMessage.typeUrl);
+function createBaseChecksums(): Checksums {
+  return {
+    checksums: []
+  };
+}
+export const Checksums = {
+  typeUrl: "/ibc.lightclients.wasm.v1.Checksums",
+  aminoType: "cosmos-sdk/Checksums",
+  is(o: any): o is Checksums {
+    return o && (o.$typeUrl === Checksums.typeUrl || Array.isArray(o.checksums) && (!o.checksums.length || o.checksums[0] instanceof Uint8Array || typeof o.checksums[0] === "string"));
+  },
+  isAmino(o: any): o is ChecksumsAmino {
+    return o && (o.$typeUrl === Checksums.typeUrl || Array.isArray(o.checksums) && (!o.checksums.length || o.checksums[0] instanceof Uint8Array || typeof o.checksums[0] === "string"));
+  },
+  encode(message: Checksums, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.checksums) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Checksums {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChecksums();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.checksums.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Checksums>): Checksums {
+    const message = createBaseChecksums();
+    message.checksums = object.checksums?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ChecksumsAmino): Checksums {
+    const message = createBaseChecksums();
+    message.checksums = object.checksums?.map(e => bytesFromBase64(e)) || [];
+    return message;
+  },
+  toAmino(message: Checksums): ChecksumsAmino {
+    const obj: any = {};
+    if (message.checksums) {
+      obj.checksums = message.checksums.map(e => base64FromBytes(e));
+    } else {
+      obj.checksums = message.checksums;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ChecksumsAminoMsg): Checksums {
+    return Checksums.fromAmino(object.value);
+  },
+  toAminoMsg(message: Checksums): ChecksumsAminoMsg {
+    return {
+      type: "cosmos-sdk/Checksums",
+      value: Checksums.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ChecksumsProtoMsg): Checksums {
+    return Checksums.decode(message.value);
+  },
+  toProto(message: Checksums): Uint8Array {
+    return Checksums.encode(message).finish();
+  },
+  toProtoMsg(message: Checksums): ChecksumsProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.Checksums",
+      value: Checksums.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Checksums.typeUrl, Checksums);
+GlobalDecoderRegistry.registerAminoProtoMapping(Checksums.aminoType, Checksums.typeUrl);

package/src/react-query.ts

@@ -0,0 +1,185 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.11.3
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+
+
+  import { getRpcClient } from './extern'
+import {
+  isRpc,
+  Rpc,
+} from './helpers'
+import {
+  ITxArgs,
+  ISigningClient,
+  StdFee,
+  DeliverTxResponse,
+  SigningClientResolver,
+  RpcResolver,
+  isISigningClient
+} from './helper-func-types'
+import {
+    useQuery,
+    useQueryClient,
+    UseQueryOptions,
+    useMutation,
+    UseMutationOptions,
+    QueryKey,
+} from '@tanstack/react-query';
+
+import { HttpEndpoint } from "@interchainjs/types";
+import { Rpc as ProtobufRpcClient } from "./helpers";
+
+export const DEFAULT_RPC_CLIENT_QUERY_KEY = 'rpcClient';
+export const DEFAULT_RPC_ENDPOINT_QUERY_KEY = 'rpcEndPoint';
+export const DEFAULT_SIGNING_CLIENT_QUERY_KEY = 'signingClient';
+
+export interface CacheResolver {
+    rpcEndpoint?: string | HttpEndpoint;
+    clientQueryKey?: string;
+}
+
+export function isCacheResolver(resolver: unknown) : resolver is CacheResolver {
+    return resolver !== null && resolver !== undefined && (resolver as CacheResolver).rpcEndpoint !== undefined && (resolver as CacheResolver).clientQueryKey !== undefined;
+}
+
+export interface ReactQueryParams<TResponse, TData = TResponse> {
+    options?: UseQueryOptions<TResponse, Error, TData>;
+}
+
+export interface UseRpcClientQuery<TData> extends ReactQueryParams<ProtobufRpcClient, TData> {
+    clientResolver?: CacheResolver;
+}
+
+
+export interface UseRpcEndpointQuery<TData> extends ReactQueryParams<string | HttpEndpoint, TData> {
+    getter: () => Promise<string | HttpEndpoint>;
+    rpcEndPointKey?: string;
+}
+
+export const useRpcEndpoint = <TData = string | HttpEndpoint>({
+    getter,
+    options,
+    rpcEndPointKey,
+}: UseRpcEndpointQuery<TData>) => {
+    const key = rpcEndPointKey || DEFAULT_RPC_ENDPOINT_QUERY_KEY;
+    return useQuery<string | HttpEndpoint, Error, TData>([key, getter], async () => {
+        return await getter();
+    }, options);
+};
+
+export const useRpcClient = <TData = ProtobufRpcClient>({
+    options,
+    clientResolver
+}: UseRpcClientQuery<TData>) => {
+    const queryClient = useQueryClient({
+      context: options?.context
+    });
+
+    const key = clientResolver?.clientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
+    return useQuery<ProtobufRpcClient, Error, TData>([key, clientResolver?.rpcEndpoint], async () => {
+      if(!clientResolver?.rpcEndpoint) {
+        throw new Error('rpcEndpoint is required');
+      }
+
+      const client = await getRpcClient(clientResolver.rpcEndpoint);
+      if(!client) {
+          throw new Error('Failed to connect to rpc client');
+      }
+
+      queryClient.setQueryData([key], client);
+
+      return client;
+    }, options);
+};
+
+export interface UseQueryBuilderOptions<TReq, TRes> {
+  builderQueryFn: (clientResolver?: RpcResolver) => (request: TReq) => Promise<TRes>,
+  queryKeyPrefix: string,
+}
+
+
+export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRes>) {
+  return <TData = TRes>({
+    request,
+    options,
+    clientResolver,
+    customizedQueryKey,
+  }: UseQueryParams<TReq, TRes, TData>) => {
+    const queryClient = useQueryClient({
+      context: options?.context
+    });
+
+    let rpcResolver: RpcResolver | undefined;
+
+    if(isRpc(clientResolver)) {
+      rpcResolver = clientResolver;
+    } else if(isCacheResolver(clientResolver)) {
+      const key = clientResolver.clientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
+      const queryKey = clientResolver.rpcEndpoint ? [key, clientResolver.rpcEndpoint] : [key];
+      rpcResolver = queryClient.getQueryData<Rpc>(queryKey);
+
+      if(!rpcResolver && clientResolver.rpcEndpoint) {
+        rpcResolver = clientResolver.rpcEndpoint;
+      }
+    } else {
+      rpcResolver = clientResolver;
+    }
+
+    const queryFn = opts.builderQueryFn(rpcResolver);
+    return useQuery<TRes, Error, TData>(customizedQueryKey || [opts.queryKeyPrefix, request], () => queryFn(request), options);
+  };
+}
+
+export interface UseQueryParams<TReq, TRes, TData = TRes> extends ReactQueryParams<TRes, TData> {
+  request: TReq;
+  clientResolver?: CacheResolver | RpcResolver;
+  customizedQueryKey?: QueryKey
+}
+
+export interface ReactMutationParams<TData, TError, TVariables, TContext = unknown> {
+  options?: UseMutationOptions<TData, TError, TVariables, TContext>;
+  clientResolver?: CacheResolver | SigningClientResolver;
+}
+
+
+export interface UseMutationBuilderOptions<TMsg> {
+  builderMutationFn: (clientResolver?: SigningClientResolver) => (
+    signerAddress: string,
+    message: TMsg,
+    fee: StdFee | 'auto',
+    memo: string
+  ) => Promise<DeliverTxResponse>,
+}
+
+
+export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<TMsg>) {
+  return ({
+    options,
+    clientResolver
+  }: ReactMutationParams<DeliverTxResponse, TError, ITxArgs<TMsg>>) => {
+    const queryClient = useQueryClient({
+      context: options?.context
+    });
+
+    let signingClientResolver: SigningClientResolver | undefined;
+
+    if(isISigningClient(clientResolver)) {
+      signingClientResolver = clientResolver;
+    } else if(isCacheResolver(clientResolver)) {
+      const key = clientResolver.clientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
+      const queryKey = clientResolver.rpcEndpoint ? [key, clientResolver.rpcEndpoint] : [key];
+      signingClientResolver = queryClient.getQueryData<ISigningClient>(queryKey);
+    } else {
+      clientResolver = clientResolver;
+    }
+
+    const mutationFn = opts.builderMutationFn(signingClientResolver);
+
+    return useMutation<DeliverTxResponse, Error, ITxArgs<TMsg>>(
+      (reqData: ITxArgs<TMsg>) => mutationFn(reqData.signerAddress, reqData.message, reqData.fee, reqData.memo),
+      options as Omit<UseMutationOptions<DeliverTxResponse, Error, ITxArgs<TMsg>, unknown>, "mutationFn">
+    );
+  };
+}