diff --git a/__fixtures__/output1/akash/audit/v1beta2/query.rpc.query.ts b/__fixtures__/output1/akash/audit/v1beta2/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/akash/audit/v1beta2/query.rpc.query.ts rename to __fixtures__/output1/akash/audit/v1beta2/query.rpc.Query.ts index e8bb9a7caf..04a2870ae6 100644 --- a/__fixtures__/output1/akash/audit/v1beta2/query.rpc.query.ts +++ b/__fixtures__/output1/akash/audit/v1beta2/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Provider, ProviderSDKType } from "./audit"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryAllProvidersAttributesRequest, QueryAllProvidersAttributesRequestSDKType, QueryProvidersResponse, QueryProvidersResponseSDKType, QueryProviderAttributesRequest, QueryProviderAttributesRequestSDKType, QueryProviderAuditorRequest, QueryProviderAuditorRequestSDKType, QueryAuditorAttributesRequest, QueryAuditorAttributesRequestSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -101,4 +103,106 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseAllProvidersAttributesQuery extends ReactQueryParams { + request?: QueryAllProvidersAttributesRequest; +} +export interface UseProviderAttributesQuery extends ReactQueryParams { + request: QueryProviderAttributesRequest; +} +export interface UseProviderAuditorAttributesQuery extends ReactQueryParams { + request: QueryProviderAuditorRequest; +} +export interface UseAuditorAttributesQuery extends ReactQueryParams { + request: QueryAuditorAttributesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAllProvidersAttributes = ({ + request, + options + }: UseAllProvidersAttributesQuery) => { + return useQuery(["allProvidersAttributesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allProvidersAttributes(request); + }, options); + }; + + const useProviderAttributes = ({ + request, + options + }: UseProviderAttributesQuery) => { + return useQuery(["providerAttributesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.providerAttributes(request); + }, options); + }; + + const useProviderAuditorAttributes = ({ + request, + options + }: UseProviderAuditorAttributesQuery) => { + return useQuery(["providerAuditorAttributesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.providerAuditorAttributes(request); + }, options); + }; + + const useAuditorAttributes = ({ + request, + options + }: UseAuditorAttributesQuery) => { + return useQuery(["auditorAttributesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.auditorAttributes(request); + }, options); + }; + + return { + /** + * AllProvidersAttributes queries all providers + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + */ + useAllProvidersAttributes, + + /** + * ProviderAttributes queries all provider signed attributes + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + */ + useProviderAttributes, + + /** + * ProviderAuditorAttributes queries provider signed attributes by specific auditor + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + */ + useProviderAuditorAttributes, + + /** + * AuditorAttributes queries all providers signed by this auditor + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + */ + useAuditorAttributes + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/akash/cert/v1beta2/query.rpc.query.ts b/__fixtures__/output1/akash/cert/v1beta2/query.rpc.Query.ts similarity index 53% rename from __fixtures__/output1/akash/cert/v1beta2/query.rpc.query.ts rename to __fixtures__/output1/akash/cert/v1beta2/query.rpc.Query.ts index 13cd90e721..3b798c5531 100644 --- a/__fixtures__/output1/akash/cert/v1beta2/query.rpc.query.ts +++ b/__fixtures__/output1/akash/cert/v1beta2/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { CertificateFilter, CertificateFilterSDKType, Certificate, CertificateSD import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../../cosmos/base/query/v1beta1/pagination"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryCertificatesRequest, QueryCertificatesRequestSDKType, QueryCertificatesResponse, QueryCertificatesResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -33,4 +35,42 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseCertificatesQuery extends ReactQueryParams { + request: QueryCertificatesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useCertificates = ({ + request, + options + }: UseCertificatesQuery) => { + return useQuery(["certificatesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.certificates(request); + }, options); + }; + + return { + /** Certificates queries certificates */ + useCertificates + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/akash/deployment/v1beta2/query.rpc.query.ts b/__fixtures__/output1/akash/deployment/v1beta2/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/akash/deployment/v1beta2/query.rpc.query.ts rename to __fixtures__/output1/akash/deployment/v1beta2/query.rpc.Query.ts index 7529006b3b..f6f833a089 100644 --- a/__fixtures__/output1/akash/deployment/v1beta2/query.rpc.query.ts +++ b/__fixtures__/output1/akash/deployment/v1beta2/query.rpc.Query.ts @@ -5,7 +5,9 @@ import { Group, GroupSDKType } from "./group"; import { Account, AccountSDKType } from "../../escrow/v1beta2/types"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryDeploymentsRequest, QueryDeploymentsRequestSDKType, QueryDeploymentsResponse, QueryDeploymentsResponseSDKType, QueryDeploymentRequest, QueryDeploymentRequestSDKType, QueryDeploymentResponse, QueryDeploymentResponseSDKType, QueryGroupRequest, QueryGroupRequestSDKType, QueryGroupResponse, QueryGroupResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -64,4 +66,74 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseDeploymentsQuery extends ReactQueryParams { + request: QueryDeploymentsRequest; +} +export interface UseDeploymentQuery extends ReactQueryParams { + request: QueryDeploymentRequest; +} +export interface UseGroupQuery extends ReactQueryParams { + request: QueryGroupRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useDeployments = ({ + request, + options + }: UseDeploymentsQuery) => { + return useQuery(["deploymentsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deployments(request); + }, options); + }; + + const useDeployment = ({ + request, + options + }: UseDeploymentQuery) => { + return useQuery(["deploymentQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deployment(request); + }, options); + }; + + const useGroup = ({ + request, + options + }: UseGroupQuery) => { + return useQuery(["groupQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.group(request); + }, options); + }; + + return { + /** Deployments queries deployments */ + useDeployments, + + /** Deployment queries deployment details */ + useDeployment, + + /** Group queries group details */ + useGroup + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/akash/escrow/v1beta1/query.rpc.query.ts b/__fixtures__/output1/akash/escrow/v1beta1/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/akash/escrow/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/akash/escrow/v1beta1/query.rpc.Query.ts index 2e735722a0..0491185c3e 100644 --- a/__fixtures__/output1/akash/escrow/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/akash/escrow/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Account, AccountSDKType, Payment, PaymentSDKType } from "./types"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryAccountsRequest, QueryAccountsRequestSDKType, QueryAccountsResponse, QueryAccountsResponseSDKType, QueryPaymentsRequest, QueryPaymentsRequestSDKType, QueryPaymentsResponse, QueryPaymentsResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -59,4 +61,66 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseAccountsQuery extends ReactQueryParams { + request: QueryAccountsRequest; +} +export interface UsePaymentsQuery extends ReactQueryParams { + request: QueryPaymentsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAccounts = ({ + request, + options + }: UseAccountsQuery) => { + return useQuery(["accountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accounts(request); + }, options); + }; + + const usePayments = ({ + request, + options + }: UsePaymentsQuery) => { + return useQuery(["paymentsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.payments(request); + }, options); + }; + + return { + /** + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + * Accounts queries all accounts + */ + useAccounts, + + /** + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + * Payments queries all payments + */ + usePayments + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/akash/escrow/v1beta2/query.rpc.query.ts b/__fixtures__/output1/akash/escrow/v1beta2/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/akash/escrow/v1beta2/query.rpc.query.ts rename to __fixtures__/output1/akash/escrow/v1beta2/query.rpc.Query.ts index 0a92b6462e..a8cecdfd2d 100644 --- a/__fixtures__/output1/akash/escrow/v1beta2/query.rpc.query.ts +++ b/__fixtures__/output1/akash/escrow/v1beta2/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Account, AccountSDKType, FractionalPayment, FractionalPaymentSDKType } from "./types"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryAccountsRequest, QueryAccountsRequestSDKType, QueryAccountsResponse, QueryAccountsResponseSDKType, QueryPaymentsRequest, QueryPaymentsRequestSDKType, QueryPaymentsResponse, QueryPaymentsResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -59,4 +61,66 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseAccountsQuery extends ReactQueryParams { + request: QueryAccountsRequest; +} +export interface UsePaymentsQuery extends ReactQueryParams { + request: QueryPaymentsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAccounts = ({ + request, + options + }: UseAccountsQuery) => { + return useQuery(["accountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accounts(request); + }, options); + }; + + const usePayments = ({ + request, + options + }: UsePaymentsQuery) => { + return useQuery(["paymentsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.payments(request); + }, options); + }; + + return { + /** + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + * Accounts queries all accounts + */ + useAccounts, + + /** + * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE + * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME + * Payments queries all payments + */ + usePayments + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/akash/market/v1beta2/query.rpc.query.ts b/__fixtures__/output1/akash/market/v1beta2/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/akash/market/v1beta2/query.rpc.query.ts rename to __fixtures__/output1/akash/market/v1beta2/query.rpc.Query.ts index f404e0063f..b62c60c718 100644 --- a/__fixtures__/output1/akash/market/v1beta2/query.rpc.query.ts +++ b/__fixtures__/output1/akash/market/v1beta2/query.rpc.Query.ts @@ -5,7 +5,9 @@ import { LeaseFilters, LeaseFiltersSDKType, LeaseID, LeaseIDSDKType, Lease, Leas import { Account, AccountSDKType, FractionalPayment, FractionalPaymentSDKType } from "../../escrow/v1beta2/types"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryOrdersRequest, QueryOrdersRequestSDKType, QueryOrdersResponse, QueryOrdersResponseSDKType, QueryOrderRequest, QueryOrderRequestSDKType, QueryOrderResponse, QueryOrderResponseSDKType, QueryBidsRequest, QueryBidsRequestSDKType, QueryBidsResponse, QueryBidsResponseSDKType, QueryBidRequest, QueryBidRequestSDKType, QueryBidResponse, QueryBidResponseSDKType, QueryLeasesRequest, QueryLeasesRequestSDKType, QueryLeasesResponse, QueryLeasesResponseSDKType, QueryLeaseRequest, QueryLeaseRequestSDKType, QueryLeaseResponse, QueryLeaseResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -106,4 +108,122 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseOrdersQuery extends ReactQueryParams { + request: QueryOrdersRequest; +} +export interface UseOrderQuery extends ReactQueryParams { + request: QueryOrderRequest; +} +export interface UseBidsQuery extends ReactQueryParams { + request: QueryBidsRequest; +} +export interface UseBidQuery extends ReactQueryParams { + request: QueryBidRequest; +} +export interface UseLeasesQuery extends ReactQueryParams { + request: QueryLeasesRequest; +} +export interface UseLeaseQuery extends ReactQueryParams { + request: QueryLeaseRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useOrders = ({ + request, + options + }: UseOrdersQuery) => { + return useQuery(["ordersQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.orders(request); + }, options); + }; + + const useOrder = ({ + request, + options + }: UseOrderQuery) => { + return useQuery(["orderQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.order(request); + }, options); + }; + + const useBids = ({ + request, + options + }: UseBidsQuery) => { + return useQuery(["bidsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.bids(request); + }, options); + }; + + const useBid = ({ + request, + options + }: UseBidQuery) => { + return useQuery(["bidQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.bid(request); + }, options); + }; + + const useLeases = ({ + request, + options + }: UseLeasesQuery) => { + return useQuery(["leasesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.leases(request); + }, options); + }; + + const useLease = ({ + request, + options + }: UseLeaseQuery) => { + return useQuery(["leaseQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.lease(request); + }, options); + }; + + return { + /** Orders queries orders with filters */ + useOrders, + + /** Order queries order details */ + useOrder, + + /** Bids queries bids with filters */ + useBids, + + /** Bid queries bid details */ + useBid, + + /** Leases queries leases with filters */ + useLeases, + + /** Lease queries lease details */ + useLease + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/akash/provider/v1beta2/query.rpc.query.ts b/__fixtures__/output1/akash/provider/v1beta2/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/akash/provider/v1beta2/query.rpc.query.ts rename to __fixtures__/output1/akash/provider/v1beta2/query.rpc.Query.ts index bedc886224..5905779112 100644 --- a/__fixtures__/output1/akash/provider/v1beta2/query.rpc.query.ts +++ b/__fixtures__/output1/akash/provider/v1beta2/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Provider, ProviderSDKType } from "./provider"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryProvidersRequest, QueryProvidersRequestSDKType, QueryProvidersResponse, QueryProvidersResponseSDKType, QueryProviderRequest, QueryProviderRequestSDKType, QueryProviderResponse, QueryProviderResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -49,4 +51,58 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseProvidersQuery extends ReactQueryParams { + request?: QueryProvidersRequest; +} +export interface UseProviderQuery extends ReactQueryParams { + request: QueryProviderRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useProviders = ({ + request, + options + }: UseProvidersQuery) => { + return useQuery(["providersQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.providers(request); + }, options); + }; + + const useProvider = ({ + request, + options + }: UseProviderQuery) => { + return useQuery(["providerQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.provider(request); + }, options); + }; + + return { + /** Providers queries providers */ + useProviders, + + /** Provider queries provider details */ + useProvider + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/app/v1alpha1/query.rpc.Query.ts b/__fixtures__/output1/cosmos/app/v1alpha1/query.rpc.Query.ts new file mode 100644 index 0000000000..0ed2764689 --- /dev/null +++ b/__fixtures__/output1/cosmos/app/v1alpha1/query.rpc.Query.ts @@ -0,0 +1,76 @@ +import { Config, ConfigSDKType } from "./config"; +import { Rpc } from "../../../helpers"; +import * as _m0 from "protobufjs/minimal"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; +import { QueryConfigRequest, QueryConfigRequestSDKType, QueryConfigResponse, QueryConfigResponseSDKType } from "./query"; + +/** Query is the app module query service. */ +export interface Query { + /** Config returns the current app config. */ + config(request?: QueryConfigRequest): Promise; +} +export class QueryClientImpl implements Query { + private readonly rpc: Rpc; + + constructor(rpc: Rpc) { + this.rpc = rpc; + this.config = this.config.bind(this); + } + + config(request: QueryConfigRequest = {}): Promise { + const data = QueryConfigRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.app.v1alpha1.Query", "Config", data); + return promise.then(data => QueryConfigResponse.decode(new _m0.Reader(data))); + } + +} +export const createRpcQueryExtension = (base: QueryClient) => { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + return { + config(request?: QueryConfigRequest): Promise { + return queryService.config(request); + } + + }; +}; +export interface UseConfigQuery extends ReactQueryParams { + request?: QueryConfigRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useConfig = ({ + request, + options + }: UseConfigQuery) => { + return useQuery(["configQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.config(request); + }, options); + }; + + return { + /** Config returns the current app config. */ + useConfig + }; +}; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/app/v1alpha1/query.rpc.query.ts b/__fixtures__/output1/cosmos/app/v1alpha1/query.rpc.query.ts deleted file mode 100644 index 9692c53583..0000000000 --- a/__fixtures__/output1/cosmos/app/v1alpha1/query.rpc.query.ts +++ /dev/null @@ -1,36 +0,0 @@ -import { Config, ConfigSDKType } from "./config"; -import { Rpc } from "../../../helpers"; -import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; -import { QueryConfigRequest, QueryConfigRequestSDKType, QueryConfigResponse, QueryConfigResponseSDKType } from "./query"; - -/** Query is the app module query service. */ -export interface Query { - /** Config returns the current app config. */ - config(request?: QueryConfigRequest): Promise; -} -export class QueryClientImpl implements Query { - private readonly rpc: Rpc; - - constructor(rpc: Rpc) { - this.rpc = rpc; - this.config = this.config.bind(this); - } - - config(request: QueryConfigRequest = {}): Promise { - const data = QueryConfigRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.app.v1alpha1.Query", "Config", data); - return promise.then(data => QueryConfigResponse.decode(new _m0.Reader(data))); - } - -} -export const createRpcQueryExtension = (base: QueryClient) => { - const rpc = createProtobufRpcClient(base); - const queryService = new QueryClientImpl(rpc); - return { - config(request?: QueryConfigRequest): Promise { - return queryService.config(request); - } - - }; -}; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/auth/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/auth/v1beta1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/cosmos/auth/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/auth/v1beta1/query.rpc.Query.ts index 967427a6c9..867083fcb1 100644 --- a/__fixtures__/output1/cosmos/auth/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/auth/v1beta1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { Any, AnySDKType } from "../../../google/protobuf/any"; import { Params, ParamsSDKType } from "./auth"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryAccountsRequest, QueryAccountsRequestSDKType, QueryAccountsResponse, QueryAccountsResponseSDKType, QueryAccountRequest, QueryAccountRequestSDKType, QueryAccountResponse, QueryAccountResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryModuleAccountsRequest, QueryModuleAccountsRequestSDKType, QueryModuleAccountsResponse, QueryModuleAccountsResponseSDKType, Bech32PrefixRequest, Bech32PrefixRequestSDKType, Bech32PrefixResponse, Bech32PrefixResponseSDKType, AddressBytesToStringRequest, AddressBytesToStringRequestSDKType, AddressBytesToStringResponse, AddressBytesToStringResponseSDKType, AddressStringToBytesRequest, AddressStringToBytesRequestSDKType, AddressStringToBytesResponse, AddressStringToBytesResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -125,4 +127,142 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseAccountsQuery extends ReactQueryParams { + request?: QueryAccountsRequest; +} +export interface UseAccountQuery extends ReactQueryParams { + request: QueryAccountRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseModuleAccountsQuery extends ReactQueryParams { + request?: QueryModuleAccountsRequest; +} +export interface UseBech32PrefixQuery extends ReactQueryParams { + request?: Bech32PrefixRequest; +} +export interface UseAddressBytesToStringQuery extends ReactQueryParams { + request: AddressBytesToStringRequest; +} +export interface UseAddressStringToBytesQuery extends ReactQueryParams { + request: AddressStringToBytesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAccounts = ({ + request, + options + }: UseAccountsQuery) => { + return useQuery(["accountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accounts(request); + }, options); + }; + + const useAccount = ({ + request, + options + }: UseAccountQuery) => { + return useQuery(["accountQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.account(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useModuleAccounts = ({ + request, + options + }: UseModuleAccountsQuery) => { + return useQuery(["moduleAccountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleAccounts(request); + }, options); + }; + + const useBech32Prefix = ({ + request, + options + }: UseBech32PrefixQuery) => { + return useQuery(["bech32PrefixQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.bech32Prefix(request); + }, options); + }; + + const useAddressBytesToString = ({ + request, + options + }: UseAddressBytesToStringQuery) => { + return useQuery(["addressBytesToStringQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.addressBytesToString(request); + }, options); + }; + + const useAddressStringToBytes = ({ + request, + options + }: UseAddressStringToBytesQuery) => { + return useQuery(["addressStringToBytesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.addressStringToBytes(request); + }, options); + }; + + return { + /** + * Accounts returns all the existing accounts + * + * Since: cosmos-sdk 0.43 + */ + useAccounts, + + /** Account returns account details based on address. */ + useAccount, + + /** Params queries all parameters. */ + useParams, + + /** ModuleAccounts returns all the existing module accounts. */ + useModuleAccounts, + + /** Bech32 queries bech32Prefix */ + useBech32Prefix, + + /** AddressBytesToString converts Account Address bytes to string */ + useAddressBytesToString, + + /** AddressStringToBytes converts Address string to bytes */ + useAddressStringToBytes + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/authz/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/authz/v1beta1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/cosmos/authz/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/authz/v1beta1/query.rpc.Query.ts index 464122c7e9..20f69aa394 100644 --- a/__fixtures__/output1/cosmos/authz/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/authz/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Grant, GrantSDKType, GrantAuthorization, GrantAuthorizationSDKType } from "./authz"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryGrantsRequest, QueryGrantsRequestSDKType, QueryGrantsResponse, QueryGrantsResponseSDKType, QueryGranterGrantsRequest, QueryGranterGrantsRequestSDKType, QueryGranterGrantsResponse, QueryGranterGrantsResponseSDKType, QueryGranteeGrantsRequest, QueryGranteeGrantsRequestSDKType, QueryGranteeGrantsResponse, QueryGranteeGrantsResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -70,4 +72,82 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseGrantsQuery extends ReactQueryParams { + request: QueryGrantsRequest; +} +export interface UseGranterGrantsQuery extends ReactQueryParams { + request: QueryGranterGrantsRequest; +} +export interface UseGranteeGrantsQuery extends ReactQueryParams { + request: QueryGranteeGrantsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useGrants = ({ + request, + options + }: UseGrantsQuery) => { + return useQuery(["grantsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.grants(request); + }, options); + }; + + const useGranterGrants = ({ + request, + options + }: UseGranterGrantsQuery) => { + return useQuery(["granterGrantsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.granterGrants(request); + }, options); + }; + + const useGranteeGrants = ({ + request, + options + }: UseGranteeGrantsQuery) => { + return useQuery(["granteeGrantsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.granteeGrants(request); + }, options); + }; + + return { + /** Returns list of `Authorization`, granted to the grantee by the granter. */ + useGrants, + + /** + * GranterGrants returns list of `GrantAuthorization`, granted by granter. + * + * Since: cosmos-sdk 0.46 + */ + useGranterGrants, + + /** + * GranteeGrants returns a list of `GrantAuthorization` by grantee. + * + * Since: cosmos-sdk 0.46 + */ + useGranteeGrants + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/bank/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/bank/v1beta1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/cosmos/bank/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/bank/v1beta1/query.rpc.Query.ts index c9f258b5ee..1f51b033c4 100644 --- a/__fixtures__/output1/cosmos/bank/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/bank/v1beta1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { Coin, CoinSDKType } from "../../base/v1beta1/coin"; import { Params, ParamsSDKType, Metadata, MetadataSDKType } from "./bank"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryBalanceRequest, QueryBalanceRequestSDKType, QueryBalanceResponse, QueryBalanceResponseSDKType, QueryAllBalancesRequest, QueryAllBalancesRequestSDKType, QueryAllBalancesResponse, QueryAllBalancesResponseSDKType, QuerySpendableBalancesRequest, QuerySpendableBalancesRequestSDKType, QuerySpendableBalancesResponse, QuerySpendableBalancesResponseSDKType, QueryTotalSupplyRequest, QueryTotalSupplyRequestSDKType, QueryTotalSupplyResponse, QueryTotalSupplyResponseSDKType, QuerySupplyOfRequest, QuerySupplyOfRequestSDKType, QuerySupplyOfResponse, QuerySupplyOfResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryDenomMetadataRequest, QueryDenomMetadataRequestSDKType, QueryDenomMetadataResponse, QueryDenomMetadataResponseSDKType, QueryDenomsMetadataRequest, QueryDenomsMetadataRequestSDKType, QueryDenomsMetadataResponse, QueryDenomsMetadataResponseSDKType, QueryDenomOwnersRequest, QueryDenomOwnersRequestSDKType, QueryDenomOwnersResponse, QueryDenomOwnersResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -160,4 +162,179 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseBalanceQuery extends ReactQueryParams { + request: QueryBalanceRequest; +} +export interface UseAllBalancesQuery extends ReactQueryParams { + request: QueryAllBalancesRequest; +} +export interface UseSpendableBalancesQuery extends ReactQueryParams { + request: QuerySpendableBalancesRequest; +} +export interface UseTotalSupplyQuery extends ReactQueryParams { + request?: QueryTotalSupplyRequest; +} +export interface UseSupplyOfQuery extends ReactQueryParams { + request: QuerySupplyOfRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseDenomMetadataQuery extends ReactQueryParams { + request: QueryDenomMetadataRequest; +} +export interface UseDenomsMetadataQuery extends ReactQueryParams { + request?: QueryDenomsMetadataRequest; +} +export interface UseDenomOwnersQuery extends ReactQueryParams { + request: QueryDenomOwnersRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useBalance = ({ + request, + options + }: UseBalanceQuery) => { + return useQuery(["balanceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.balance(request); + }, options); + }; + + const useAllBalances = ({ + request, + options + }: UseAllBalancesQuery) => { + return useQuery(["allBalancesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allBalances(request); + }, options); + }; + + const useSpendableBalances = ({ + request, + options + }: UseSpendableBalancesQuery) => { + return useQuery(["spendableBalancesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.spendableBalances(request); + }, options); + }; + + const useTotalSupply = ({ + request, + options + }: UseTotalSupplyQuery) => { + return useQuery(["totalSupplyQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalSupply(request); + }, options); + }; + + const useSupplyOf = ({ + request, + options + }: UseSupplyOfQuery) => { + return useQuery(["supplyOfQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.supplyOf(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useDenomMetadata = ({ + request, + options + }: UseDenomMetadataQuery) => { + return useQuery(["denomMetadataQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomMetadata(request); + }, options); + }; + + const useDenomsMetadata = ({ + request, + options + }: UseDenomsMetadataQuery) => { + return useQuery(["denomsMetadataQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomsMetadata(request); + }, options); + }; + + const useDenomOwners = ({ + request, + options + }: UseDenomOwnersQuery) => { + return useQuery(["denomOwnersQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomOwners(request); + }, options); + }; + + return { + /** Balance queries the balance of a single coin for a single account. */ + useBalance, + + /** AllBalances queries the balance of all coins for a single account. */ + useAllBalances, + + /** + * SpendableBalances queries the spenable balance of all coins for a single + * account. + */ + useSpendableBalances, + + /** TotalSupply queries the total supply of all coins. */ + useTotalSupply, + + /** SupplyOf queries the supply of a single coin. */ + useSupplyOf, + + /** Params queries the parameters of x/bank module. */ + useParams, + + /** DenomsMetadata queries the client metadata of a given coin denomination. */ + useDenomMetadata, + + /** + * DenomsMetadata queries the client metadata for all registered coin + * denominations. + */ + useDenomsMetadata, + + /** + * DenomOwners queries for all account addresses that own a particular token + * denomination. + */ + useDenomOwners + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/base/reflection/v1beta1/reflection.rpc.ReflectionService.ts b/__fixtures__/output1/cosmos/base/reflection/v1beta1/reflection.rpc.ReflectionService.ts index 232363cf23..9e1a03a0d0 100644 --- a/__fixtures__/output1/cosmos/base/reflection/v1beta1/reflection.rpc.ReflectionService.ts +++ b/__fixtures__/output1/cosmos/base/reflection/v1beta1/reflection.rpc.ReflectionService.ts @@ -1,6 +1,8 @@ import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { ListAllInterfacesRequest, ListAllInterfacesRequestSDKType, ListAllInterfacesResponse, ListAllInterfacesResponseSDKType, ListImplementationsRequest, ListImplementationsRequestSDKType, ListImplementationsResponse, ListImplementationsResponseSDKType } from "./reflection"; /** ReflectionService defines a service for interface reflection. */ @@ -52,4 +54,64 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseListAllInterfacesQuery extends ReactQueryParams { + request?: ListAllInterfacesRequest; +} +export interface UseListImplementationsQuery extends ReactQueryParams { + request: ListImplementationsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useListAllInterfaces = ({ + request, + options + }: UseListAllInterfacesQuery) => { + return useQuery(["listAllInterfacesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.listAllInterfaces(request); + }, options); + }; + + const useListImplementations = ({ + request, + options + }: UseListImplementationsQuery) => { + return useQuery(["listImplementationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.listImplementations(request); + }, options); + }; + + return { + /** + * ListAllInterfaces lists all the interfaces registered in the interface + * registry. + */ + useListAllInterfaces, + + /** + * ListImplementations list all the concrete types that implement a given + * interface. + */ + useListImplementations + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/base/reflection/v2alpha1/reflection.rpc.ReflectionService.ts b/__fixtures__/output1/cosmos/base/reflection/v2alpha1/reflection.rpc.ReflectionService.ts index 847cc30f3b..4c0a9bb01e 100644 --- a/__fixtures__/output1/cosmos/base/reflection/v2alpha1/reflection.rpc.ReflectionService.ts +++ b/__fixtures__/output1/cosmos/base/reflection/v2alpha1/reflection.rpc.ReflectionService.ts @@ -1,6 +1,8 @@ import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { GetAuthnDescriptorRequest, GetAuthnDescriptorRequestSDKType, GetAuthnDescriptorResponse, GetAuthnDescriptorResponseSDKType, GetChainDescriptorRequest, GetChainDescriptorRequestSDKType, GetChainDescriptorResponse, GetChainDescriptorResponseSDKType, GetCodecDescriptorRequest, GetCodecDescriptorRequestSDKType, GetCodecDescriptorResponse, GetCodecDescriptorResponseSDKType, GetConfigurationDescriptorRequest, GetConfigurationDescriptorRequestSDKType, GetConfigurationDescriptorResponse, GetConfigurationDescriptorResponseSDKType, GetQueryServicesDescriptorRequest, GetQueryServicesDescriptorRequestSDKType, GetQueryServicesDescriptorResponse, GetQueryServicesDescriptorResponseSDKType, GetTxDescriptorRequest, GetTxDescriptorRequestSDKType, GetTxDescriptorResponse, GetTxDescriptorResponseSDKType } from "./reflection"; /** ReflectionService defines a service for application reflection. */ @@ -106,4 +108,126 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseGetAuthnDescriptorQuery extends ReactQueryParams { + request?: GetAuthnDescriptorRequest; +} +export interface UseGetChainDescriptorQuery extends ReactQueryParams { + request?: GetChainDescriptorRequest; +} +export interface UseGetCodecDescriptorQuery extends ReactQueryParams { + request?: GetCodecDescriptorRequest; +} +export interface UseGetConfigurationDescriptorQuery extends ReactQueryParams { + request?: GetConfigurationDescriptorRequest; +} +export interface UseGetQueryServicesDescriptorQuery extends ReactQueryParams { + request?: GetQueryServicesDescriptorRequest; +} +export interface UseGetTxDescriptorQuery extends ReactQueryParams { + request?: GetTxDescriptorRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useGetAuthnDescriptor = ({ + request, + options + }: UseGetAuthnDescriptorQuery) => { + return useQuery(["getAuthnDescriptorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getAuthnDescriptor(request); + }, options); + }; + + const useGetChainDescriptor = ({ + request, + options + }: UseGetChainDescriptorQuery) => { + return useQuery(["getChainDescriptorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getChainDescriptor(request); + }, options); + }; + + const useGetCodecDescriptor = ({ + request, + options + }: UseGetCodecDescriptorQuery) => { + return useQuery(["getCodecDescriptorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getCodecDescriptor(request); + }, options); + }; + + const useGetConfigurationDescriptor = ({ + request, + options + }: UseGetConfigurationDescriptorQuery) => { + return useQuery(["getConfigurationDescriptorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getConfigurationDescriptor(request); + }, options); + }; + + const useGetQueryServicesDescriptor = ({ + request, + options + }: UseGetQueryServicesDescriptorQuery) => { + return useQuery(["getQueryServicesDescriptorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getQueryServicesDescriptor(request); + }, options); + }; + + const useGetTxDescriptor = ({ + request, + options + }: UseGetTxDescriptorQuery) => { + return useQuery(["getTxDescriptorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getTxDescriptor(request); + }, options); + }; + + return { + /** + * GetAuthnDescriptor returns information on how to authenticate transactions in the application + * NOTE: this RPC is still experimental and might be subject to breaking changes or removal in + * future releases of the cosmos-sdk. + */ + useGetAuthnDescriptor, + + /** GetChainDescriptor returns the description of the chain */ + useGetChainDescriptor, + + /** GetCodecDescriptor returns the descriptor of the codec of the application */ + useGetCodecDescriptor, + + /** GetConfigurationDescriptor returns the descriptor for the sdk.Config of the application */ + useGetConfigurationDescriptor, + + /** GetQueryServicesDescriptor returns the available gRPC queryable services of the application */ + useGetQueryServicesDescriptor, + + /** GetTxDescriptor returns information on the used transaction object and available msgs that can be used */ + useGetTxDescriptor + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.Service.ts b/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.Service.ts index ed0f9f4153..44271b745c 100644 --- a/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.Service.ts +++ b/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.Service.ts @@ -5,7 +5,9 @@ import { Block, BlockSDKType } from "../../../../tendermint/types/block"; import { NodeInfo, NodeInfoSDKType } from "../../../../tendermint/p2p/types"; import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { GetNodeInfoRequest, GetNodeInfoRequestSDKType, GetNodeInfoResponse, GetNodeInfoResponseSDKType, GetSyncingRequest, GetSyncingRequestSDKType, GetSyncingResponse, GetSyncingResponseSDKType, GetLatestBlockRequest, GetLatestBlockRequestSDKType, GetLatestBlockResponse, GetLatestBlockResponseSDKType, GetBlockByHeightRequest, GetBlockByHeightRequestSDKType, GetBlockByHeightResponse, GetBlockByHeightResponseSDKType, GetLatestValidatorSetRequest, GetLatestValidatorSetRequestSDKType, GetLatestValidatorSetResponse, GetLatestValidatorSetResponseSDKType, GetValidatorSetByHeightRequest, GetValidatorSetByHeightRequestSDKType, GetValidatorSetByHeightResponse, GetValidatorSetByHeightResponseSDKType } from "./query"; /** Service defines the gRPC querier service for tendermint queries. */ @@ -109,4 +111,122 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseGetNodeInfoQuery extends ReactQueryParams { + request?: GetNodeInfoRequest; +} +export interface UseGetSyncingQuery extends ReactQueryParams { + request?: GetSyncingRequest; +} +export interface UseGetLatestBlockQuery extends ReactQueryParams { + request?: GetLatestBlockRequest; +} +export interface UseGetBlockByHeightQuery extends ReactQueryParams { + request: GetBlockByHeightRequest; +} +export interface UseGetLatestValidatorSetQuery extends ReactQueryParams { + request?: GetLatestValidatorSetRequest; +} +export interface UseGetValidatorSetByHeightQuery extends ReactQueryParams { + request: GetValidatorSetByHeightRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useGetNodeInfo = ({ + request, + options + }: UseGetNodeInfoQuery) => { + return useQuery(["getNodeInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getNodeInfo(request); + }, options); + }; + + const useGetSyncing = ({ + request, + options + }: UseGetSyncingQuery) => { + return useQuery(["getSyncingQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getSyncing(request); + }, options); + }; + + const useGetLatestBlock = ({ + request, + options + }: UseGetLatestBlockQuery) => { + return useQuery(["getLatestBlockQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getLatestBlock(request); + }, options); + }; + + const useGetBlockByHeight = ({ + request, + options + }: UseGetBlockByHeightQuery) => { + return useQuery(["getBlockByHeightQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getBlockByHeight(request); + }, options); + }; + + const useGetLatestValidatorSet = ({ + request, + options + }: UseGetLatestValidatorSetQuery) => { + return useQuery(["getLatestValidatorSetQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getLatestValidatorSet(request); + }, options); + }; + + const useGetValidatorSetByHeight = ({ + request, + options + }: UseGetValidatorSetByHeightQuery) => { + return useQuery(["getValidatorSetByHeightQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getValidatorSetByHeight(request); + }, options); + }; + + return { + /** GetNodeInfo queries the current node info. */ + useGetNodeInfo, + + /** GetSyncing queries node syncing. */ + useGetSyncing, + + /** GetLatestBlock returns the latest block. */ + useGetLatestBlock, + + /** GetBlockByHeight queries block for given height. */ + useGetBlockByHeight, + + /** GetLatestValidatorSet queries latest validator-set. */ + useGetLatestValidatorSet, + + /** GetValidatorSetByHeight queries validator-set at a given height. */ + useGetValidatorSetByHeight + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.svc.ts b/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.svc.ts deleted file mode 100644 index ed0f9f4153..0000000000 --- a/__fixtures__/output1/cosmos/base/tendermint/v1beta1/query.rpc.svc.ts +++ /dev/null @@ -1,112 +0,0 @@ -import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../query/v1beta1/pagination"; -import { Any, AnySDKType } from "../../../../google/protobuf/any"; -import { BlockID, BlockIDSDKType } from "../../../../tendermint/types/types"; -import { Block, BlockSDKType } from "../../../../tendermint/types/block"; -import { NodeInfo, NodeInfoSDKType } from "../../../../tendermint/p2p/types"; -import { Rpc } from "../../../../helpers"; -import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; -import { GetNodeInfoRequest, GetNodeInfoRequestSDKType, GetNodeInfoResponse, GetNodeInfoResponseSDKType, GetSyncingRequest, GetSyncingRequestSDKType, GetSyncingResponse, GetSyncingResponseSDKType, GetLatestBlockRequest, GetLatestBlockRequestSDKType, GetLatestBlockResponse, GetLatestBlockResponseSDKType, GetBlockByHeightRequest, GetBlockByHeightRequestSDKType, GetBlockByHeightResponse, GetBlockByHeightResponseSDKType, GetLatestValidatorSetRequest, GetLatestValidatorSetRequestSDKType, GetLatestValidatorSetResponse, GetLatestValidatorSetResponseSDKType, GetValidatorSetByHeightRequest, GetValidatorSetByHeightRequestSDKType, GetValidatorSetByHeightResponse, GetValidatorSetByHeightResponseSDKType } from "./query"; - -/** Service defines the gRPC querier service for tendermint queries. */ -export interface Service { - /** GetNodeInfo queries the current node info. */ - getNodeInfo(request?: GetNodeInfoRequest): Promise; - - /** GetSyncing queries node syncing. */ - getSyncing(request?: GetSyncingRequest): Promise; - - /** GetLatestBlock returns the latest block. */ - getLatestBlock(request?: GetLatestBlockRequest): Promise; - - /** GetBlockByHeight queries block for given height. */ - getBlockByHeight(request: GetBlockByHeightRequest): Promise; - - /** GetLatestValidatorSet queries latest validator-set. */ - getLatestValidatorSet(request?: GetLatestValidatorSetRequest): Promise; - - /** GetValidatorSetByHeight queries validator-set at a given height. */ - getValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise; -} -export class ServiceClientImpl implements Service { - private readonly rpc: Rpc; - - constructor(rpc: Rpc) { - this.rpc = rpc; - this.getNodeInfo = this.getNodeInfo.bind(this); - this.getSyncing = this.getSyncing.bind(this); - this.getLatestBlock = this.getLatestBlock.bind(this); - this.getBlockByHeight = this.getBlockByHeight.bind(this); - this.getLatestValidatorSet = this.getLatestValidatorSet.bind(this); - this.getValidatorSetByHeight = this.getValidatorSetByHeight.bind(this); - } - - getNodeInfo(request: GetNodeInfoRequest = {}): Promise { - const data = GetNodeInfoRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetNodeInfo", data); - return promise.then(data => GetNodeInfoResponse.decode(new _m0.Reader(data))); - } - - getSyncing(request: GetSyncingRequest = {}): Promise { - const data = GetSyncingRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetSyncing", data); - return promise.then(data => GetSyncingResponse.decode(new _m0.Reader(data))); - } - - getLatestBlock(request: GetLatestBlockRequest = {}): Promise { - const data = GetLatestBlockRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetLatestBlock", data); - return promise.then(data => GetLatestBlockResponse.decode(new _m0.Reader(data))); - } - - getBlockByHeight(request: GetBlockByHeightRequest): Promise { - const data = GetBlockByHeightRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetBlockByHeight", data); - return promise.then(data => GetBlockByHeightResponse.decode(new _m0.Reader(data))); - } - - getLatestValidatorSet(request: GetLatestValidatorSetRequest = { - pagination: undefined - }): Promise { - const data = GetLatestValidatorSetRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetLatestValidatorSet", data); - return promise.then(data => GetLatestValidatorSetResponse.decode(new _m0.Reader(data))); - } - - getValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise { - const data = GetValidatorSetByHeightRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetValidatorSetByHeight", data); - return promise.then(data => GetValidatorSetByHeightResponse.decode(new _m0.Reader(data))); - } - -} -export const createRpcQueryExtension = (base: QueryClient) => { - const rpc = createProtobufRpcClient(base); - const queryService = new ServiceClientImpl(rpc); - return { - getNodeInfo(request?: GetNodeInfoRequest): Promise { - return queryService.getNodeInfo(request); - }, - - getSyncing(request?: GetSyncingRequest): Promise { - return queryService.getSyncing(request); - }, - - getLatestBlock(request?: GetLatestBlockRequest): Promise { - return queryService.getLatestBlock(request); - }, - - getBlockByHeight(request: GetBlockByHeightRequest): Promise { - return queryService.getBlockByHeight(request); - }, - - getLatestValidatorSet(request?: GetLatestValidatorSetRequest): Promise { - return queryService.getLatestValidatorSet(request); - }, - - getValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise { - return queryService.getValidatorSetByHeight(request); - } - - }; -}; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/distribution/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/distribution/v1beta1/query.rpc.Query.ts similarity index 58% rename from __fixtures__/output1/cosmos/distribution/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/distribution/v1beta1/query.rpc.Query.ts index e765981cc6..106ab9b434 100644 --- a/__fixtures__/output1/cosmos/distribution/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/distribution/v1beta1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { Params, ParamsSDKType, ValidatorOutstandingRewards, ValidatorOutstandin import { DecCoin, DecCoinSDKType } from "../../base/v1beta1/coin"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsRequestSDKType, QueryValidatorOutstandingRewardsResponse, QueryValidatorOutstandingRewardsResponseSDKType, QueryValidatorCommissionRequest, QueryValidatorCommissionRequestSDKType, QueryValidatorCommissionResponse, QueryValidatorCommissionResponseSDKType, QueryValidatorSlashesRequest, QueryValidatorSlashesRequestSDKType, QueryValidatorSlashesResponse, QueryValidatorSlashesResponseSDKType, QueryDelegationRewardsRequest, QueryDelegationRewardsRequestSDKType, QueryDelegationRewardsResponse, QueryDelegationRewardsResponseSDKType, QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsRequestSDKType, QueryDelegationTotalRewardsResponse, QueryDelegationTotalRewardsResponseSDKType, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsRequestSDKType, QueryDelegatorValidatorsResponse, QueryDelegatorValidatorsResponseSDKType, QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressRequestSDKType, QueryDelegatorWithdrawAddressResponse, QueryDelegatorWithdrawAddressResponseSDKType, QueryCommunityPoolRequest, QueryCommunityPoolRequestSDKType, QueryCommunityPoolResponse, QueryCommunityPoolResponseSDKType } from "./query"; /** Query defines the gRPC querier service for distribution module. */ @@ -150,4 +152,173 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseValidatorOutstandingRewardsQuery extends ReactQueryParams { + request: QueryValidatorOutstandingRewardsRequest; +} +export interface UseValidatorCommissionQuery extends ReactQueryParams { + request: QueryValidatorCommissionRequest; +} +export interface UseValidatorSlashesQuery extends ReactQueryParams { + request: QueryValidatorSlashesRequest; +} +export interface UseDelegationRewardsQuery extends ReactQueryParams { + request: QueryDelegationRewardsRequest; +} +export interface UseDelegationTotalRewardsQuery extends ReactQueryParams { + request: QueryDelegationTotalRewardsRequest; +} +export interface UseDelegatorValidatorsQuery extends ReactQueryParams { + request: QueryDelegatorValidatorsRequest; +} +export interface UseDelegatorWithdrawAddressQuery extends ReactQueryParams { + request: QueryDelegatorWithdrawAddressRequest; +} +export interface UseCommunityPoolQuery extends ReactQueryParams { + request?: QueryCommunityPoolRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useValidatorOutstandingRewards = ({ + request, + options + }: UseValidatorOutstandingRewardsQuery) => { + return useQuery(["validatorOutstandingRewardsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validatorOutstandingRewards(request); + }, options); + }; + + const useValidatorCommission = ({ + request, + options + }: UseValidatorCommissionQuery) => { + return useQuery(["validatorCommissionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validatorCommission(request); + }, options); + }; + + const useValidatorSlashes = ({ + request, + options + }: UseValidatorSlashesQuery) => { + return useQuery(["validatorSlashesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validatorSlashes(request); + }, options); + }; + + const useDelegationRewards = ({ + request, + options + }: UseDelegationRewardsQuery) => { + return useQuery(["delegationRewardsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegationRewards(request); + }, options); + }; + + const useDelegationTotalRewards = ({ + request, + options + }: UseDelegationTotalRewardsQuery) => { + return useQuery(["delegationTotalRewardsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegationTotalRewards(request); + }, options); + }; + + const useDelegatorValidators = ({ + request, + options + }: UseDelegatorValidatorsQuery) => { + return useQuery(["delegatorValidatorsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegatorValidators(request); + }, options); + }; + + const useDelegatorWithdrawAddress = ({ + request, + options + }: UseDelegatorWithdrawAddressQuery) => { + return useQuery(["delegatorWithdrawAddressQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegatorWithdrawAddress(request); + }, options); + }; + + const useCommunityPool = ({ + request, + options + }: UseCommunityPoolQuery) => { + return useQuery(["communityPoolQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.communityPool(request); + }, options); + }; + + return { + /** Params queries params of the distribution module. */ + useParams, + + /** ValidatorOutstandingRewards queries rewards of a validator address. */ + useValidatorOutstandingRewards, + + /** ValidatorCommission queries accumulated commission for a validator. */ + useValidatorCommission, + + /** ValidatorSlashes queries slash events of a validator. */ + useValidatorSlashes, + + /** DelegationRewards queries the total rewards accrued by a delegation. */ + useDelegationRewards, + + /** + * DelegationTotalRewards queries the total rewards accrued by a each + * validator. + */ + useDelegationTotalRewards, + + /** DelegatorValidators queries the validators of a delegator. */ + useDelegatorValidators, + + /** DelegatorWithdrawAddress queries withdraw address of a delegator. */ + useDelegatorWithdrawAddress, + + /** CommunityPool queries the community pool coins. */ + useCommunityPool + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/evidence/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/evidence/v1beta1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/cosmos/evidence/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/evidence/v1beta1/query.rpc.Query.ts index ef3e9eef84..92ed6a4f14 100644 --- a/__fixtures__/output1/cosmos/evidence/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/evidence/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Any, AnySDKType } from "../../../google/protobuf/any"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryEvidenceRequest, QueryEvidenceRequestSDKType, QueryEvidenceResponse, QueryEvidenceResponseSDKType, QueryAllEvidenceRequest, QueryAllEvidenceRequestSDKType, QueryAllEvidenceResponse, QueryAllEvidenceResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -50,4 +52,58 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseEvidenceQuery extends ReactQueryParams { + request: QueryEvidenceRequest; +} +export interface UseAllEvidenceQuery extends ReactQueryParams { + request?: QueryAllEvidenceRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useEvidence = ({ + request, + options + }: UseEvidenceQuery) => { + return useQuery(["evidenceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.evidence(request); + }, options); + }; + + const useAllEvidence = ({ + request, + options + }: UseAllEvidenceQuery) => { + return useQuery(["allEvidenceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allEvidence(request); + }, options); + }; + + return { + /** Evidence queries evidence based on evidence hash. */ + useEvidence, + + /** AllEvidence queries all evidence. */ + useAllEvidence + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/feegrant/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/feegrant/v1beta1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/cosmos/feegrant/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/feegrant/v1beta1/query.rpc.Query.ts index b755e38c8e..1ef6435752 100644 --- a/__fixtures__/output1/cosmos/feegrant/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/feegrant/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Grant, GrantSDKType } from "./feegrant"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryAllowanceRequest, QueryAllowanceRequestSDKType, QueryAllowanceResponse, QueryAllowanceResponseSDKType, QueryAllowancesRequest, QueryAllowancesRequestSDKType, QueryAllowancesResponse, QueryAllowancesResponseSDKType, QueryAllowancesByGranterRequest, QueryAllowancesByGranterRequestSDKType, QueryAllowancesByGranterResponse, QueryAllowancesByGranterResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -65,4 +67,77 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseAllowanceQuery extends ReactQueryParams { + request: QueryAllowanceRequest; +} +export interface UseAllowancesQuery extends ReactQueryParams { + request: QueryAllowancesRequest; +} +export interface UseAllowancesByGranterQuery extends ReactQueryParams { + request: QueryAllowancesByGranterRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAllowance = ({ + request, + options + }: UseAllowanceQuery) => { + return useQuery(["allowanceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allowance(request); + }, options); + }; + + const useAllowances = ({ + request, + options + }: UseAllowancesQuery) => { + return useQuery(["allowancesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allowances(request); + }, options); + }; + + const useAllowancesByGranter = ({ + request, + options + }: UseAllowancesByGranterQuery) => { + return useQuery(["allowancesByGranterQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allowancesByGranter(request); + }, options); + }; + + return { + /** Allowance returns fee granted to the grantee by the granter. */ + useAllowance, + + /** Allowances returns all the grants for address. */ + useAllowances, + + /** + * AllowancesByGranter returns all the grants given by an address + * Since v0.46 + */ + useAllowancesByGranter + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/gov/v1/query.rpc.query.ts b/__fixtures__/output1/cosmos/gov/v1/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/cosmos/gov/v1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/gov/v1/query.rpc.Query.ts index d67566d857..6d6128d841 100644 --- a/__fixtures__/output1/cosmos/gov/v1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/gov/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { ProposalStatus, ProposalStatusSDKType, Proposal, ProposalSDKType, Vote, import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../base/query/v1beta1/pagination"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryProposalRequest, QueryProposalRequestSDKType, QueryProposalResponse, QueryProposalResponseSDKType, QueryProposalsRequest, QueryProposalsRequestSDKType, QueryProposalsResponse, QueryProposalsResponseSDKType, QueryVoteRequest, QueryVoteRequestSDKType, QueryVoteResponse, QueryVoteResponseSDKType, QueryVotesRequest, QueryVotesRequestSDKType, QueryVotesResponse, QueryVotesResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryDepositRequest, QueryDepositRequestSDKType, QueryDepositResponse, QueryDepositResponseSDKType, QueryDepositsRequest, QueryDepositsRequestSDKType, QueryDepositsResponse, QueryDepositsResponseSDKType, QueryTallyResultRequest, QueryTallyResultRequestSDKType, QueryTallyResultResponse, QueryTallyResultResponseSDKType } from "./query"; /** Query defines the gRPC querier service for gov module */ @@ -132,4 +134,154 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseProposalQuery extends ReactQueryParams { + request: QueryProposalRequest; +} +export interface UseProposalsQuery extends ReactQueryParams { + request: QueryProposalsRequest; +} +export interface UseVoteQuery extends ReactQueryParams { + request: QueryVoteRequest; +} +export interface UseVotesQuery extends ReactQueryParams { + request: QueryVotesRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request: QueryParamsRequest; +} +export interface UseDepositQuery extends ReactQueryParams { + request: QueryDepositRequest; +} +export interface UseDepositsQuery extends ReactQueryParams { + request: QueryDepositsRequest; +} +export interface UseTallyResultQuery extends ReactQueryParams { + request: QueryTallyResultRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useProposal = ({ + request, + options + }: UseProposalQuery) => { + return useQuery(["proposalQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.proposal(request); + }, options); + }; + + const useProposals = ({ + request, + options + }: UseProposalsQuery) => { + return useQuery(["proposalsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.proposals(request); + }, options); + }; + + const useVote = ({ + request, + options + }: UseVoteQuery) => { + return useQuery(["voteQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.vote(request); + }, options); + }; + + const useVotes = ({ + request, + options + }: UseVotesQuery) => { + return useQuery(["votesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.votes(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useDeposit = ({ + request, + options + }: UseDepositQuery) => { + return useQuery(["depositQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deposit(request); + }, options); + }; + + const useDeposits = ({ + request, + options + }: UseDepositsQuery) => { + return useQuery(["depositsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deposits(request); + }, options); + }; + + const useTallyResult = ({ + request, + options + }: UseTallyResultQuery) => { + return useQuery(["tallyResultQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.tallyResult(request); + }, options); + }; + + return { + /** Proposal queries proposal details based on ProposalID. */ + useProposal, + + /** Proposals queries all proposals based on given status. */ + useProposals, + + /** Vote queries voted information based on proposalID, voterAddr. */ + useVote, + + /** Votes queries votes of a given proposal. */ + useVotes, + + /** Params queries all parameters of the gov module. */ + useParams, + + /** Deposit queries single deposit information based proposalID, depositAddr. */ + useDeposit, + + /** Deposits queries all deposits of a single proposal. */ + useDeposits, + + /** TallyResult queries the tally of a proposal vote. */ + useTallyResult + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/gov/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/gov/v1beta1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/cosmos/gov/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/gov/v1beta1/query.rpc.Query.ts index 38b8051a37..4c81611394 100644 --- a/__fixtures__/output1/cosmos/gov/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/gov/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { ProposalStatus, ProposalStatusSDKType, Proposal, ProposalSDKType, Vote, import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../base/query/v1beta1/pagination"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryProposalRequest, QueryProposalRequestSDKType, QueryProposalResponse, QueryProposalResponseSDKType, QueryProposalsRequest, QueryProposalsRequestSDKType, QueryProposalsResponse, QueryProposalsResponseSDKType, QueryVoteRequest, QueryVoteRequestSDKType, QueryVoteResponse, QueryVoteResponseSDKType, QueryVotesRequest, QueryVotesRequestSDKType, QueryVotesResponse, QueryVotesResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryDepositRequest, QueryDepositRequestSDKType, QueryDepositResponse, QueryDepositResponseSDKType, QueryDepositsRequest, QueryDepositsRequestSDKType, QueryDepositsResponse, QueryDepositsResponseSDKType, QueryTallyResultRequest, QueryTallyResultRequestSDKType, QueryTallyResultResponse, QueryTallyResultResponseSDKType } from "./query"; /** Query defines the gRPC querier service for gov module */ @@ -132,4 +134,154 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseProposalQuery extends ReactQueryParams { + request: QueryProposalRequest; +} +export interface UseProposalsQuery extends ReactQueryParams { + request: QueryProposalsRequest; +} +export interface UseVoteQuery extends ReactQueryParams { + request: QueryVoteRequest; +} +export interface UseVotesQuery extends ReactQueryParams { + request: QueryVotesRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request: QueryParamsRequest; +} +export interface UseDepositQuery extends ReactQueryParams { + request: QueryDepositRequest; +} +export interface UseDepositsQuery extends ReactQueryParams { + request: QueryDepositsRequest; +} +export interface UseTallyResultQuery extends ReactQueryParams { + request: QueryTallyResultRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useProposal = ({ + request, + options + }: UseProposalQuery) => { + return useQuery(["proposalQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.proposal(request); + }, options); + }; + + const useProposals = ({ + request, + options + }: UseProposalsQuery) => { + return useQuery(["proposalsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.proposals(request); + }, options); + }; + + const useVote = ({ + request, + options + }: UseVoteQuery) => { + return useQuery(["voteQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.vote(request); + }, options); + }; + + const useVotes = ({ + request, + options + }: UseVotesQuery) => { + return useQuery(["votesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.votes(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useDeposit = ({ + request, + options + }: UseDepositQuery) => { + return useQuery(["depositQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deposit(request); + }, options); + }; + + const useDeposits = ({ + request, + options + }: UseDepositsQuery) => { + return useQuery(["depositsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deposits(request); + }, options); + }; + + const useTallyResult = ({ + request, + options + }: UseTallyResultQuery) => { + return useQuery(["tallyResultQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.tallyResult(request); + }, options); + }; + + return { + /** Proposal queries proposal details based on ProposalID. */ + useProposal, + + /** Proposals queries all proposals based on given status. */ + useProposals, + + /** Vote queries voted information based on proposalID, voterAddr. */ + useVote, + + /** Votes queries votes of a given proposal. */ + useVotes, + + /** Params queries all parameters of the gov module. */ + useParams, + + /** Deposit queries single deposit information based proposalID, depositAddr. */ + useDeposit, + + /** Deposits queries all deposits of a single proposal. */ + useDeposits, + + /** TallyResult queries the tally of a proposal vote. */ + useTallyResult + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/group/v1/query.rpc.query.ts b/__fixtures__/output1/cosmos/group/v1/query.rpc.Query.ts similarity index 57% rename from __fixtures__/output1/cosmos/group/v1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/group/v1/query.rpc.Query.ts index 1ad4d14790..686044fe3f 100644 --- a/__fixtures__/output1/cosmos/group/v1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/group/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { GroupInfo, GroupInfoSDKType, GroupPolicyInfo, GroupPolicyInfoSDKType, GroupMember, GroupMemberSDKType, Proposal, ProposalSDKType, Vote, VoteSDKType, TallyResult, TallyResultSDKType } from "./types"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryGroupInfoRequest, QueryGroupInfoRequestSDKType, QueryGroupInfoResponse, QueryGroupInfoResponseSDKType, QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoRequestSDKType, QueryGroupPolicyInfoResponse, QueryGroupPolicyInfoResponseSDKType, QueryGroupMembersRequest, QueryGroupMembersRequestSDKType, QueryGroupMembersResponse, QueryGroupMembersResponseSDKType, QueryGroupsByAdminRequest, QueryGroupsByAdminRequestSDKType, QueryGroupsByAdminResponse, QueryGroupsByAdminResponseSDKType, QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupRequestSDKType, QueryGroupPoliciesByGroupResponse, QueryGroupPoliciesByGroupResponseSDKType, QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminRequestSDKType, QueryGroupPoliciesByAdminResponse, QueryGroupPoliciesByAdminResponseSDKType, QueryProposalRequest, QueryProposalRequestSDKType, QueryProposalResponse, QueryProposalResponseSDKType, QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyRequestSDKType, QueryProposalsByGroupPolicyResponse, QueryProposalsByGroupPolicyResponseSDKType, QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterRequestSDKType, QueryVoteByProposalVoterResponse, QueryVoteByProposalVoterResponseSDKType, QueryVotesByProposalRequest, QueryVotesByProposalRequestSDKType, QueryVotesByProposalResponse, QueryVotesByProposalResponseSDKType, QueryVotesByVoterRequest, QueryVotesByVoterRequestSDKType, QueryVotesByVoterResponse, QueryVotesByVoterResponseSDKType, QueryGroupsByMemberRequest, QueryGroupsByMemberRequestSDKType, QueryGroupsByMemberResponse, QueryGroupsByMemberResponseSDKType, QueryTallyResultRequest, QueryTallyResultRequestSDKType, QueryTallyResultResponse, QueryTallyResultResponseSDKType } from "./query"; /** Query is the cosmos.group.v1 Query service. */ @@ -202,4 +204,234 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseGroupInfoQuery extends ReactQueryParams { + request: QueryGroupInfoRequest; +} +export interface UseGroupPolicyInfoQuery extends ReactQueryParams { + request: QueryGroupPolicyInfoRequest; +} +export interface UseGroupMembersQuery extends ReactQueryParams { + request: QueryGroupMembersRequest; +} +export interface UseGroupsByAdminQuery extends ReactQueryParams { + request: QueryGroupsByAdminRequest; +} +export interface UseGroupPoliciesByGroupQuery extends ReactQueryParams { + request: QueryGroupPoliciesByGroupRequest; +} +export interface UseGroupPoliciesByAdminQuery extends ReactQueryParams { + request: QueryGroupPoliciesByAdminRequest; +} +export interface UseProposalQuery extends ReactQueryParams { + request: QueryProposalRequest; +} +export interface UseProposalsByGroupPolicyQuery extends ReactQueryParams { + request: QueryProposalsByGroupPolicyRequest; +} +export interface UseVoteByProposalVoterQuery extends ReactQueryParams { + request: QueryVoteByProposalVoterRequest; +} +export interface UseVotesByProposalQuery extends ReactQueryParams { + request: QueryVotesByProposalRequest; +} +export interface UseVotesByVoterQuery extends ReactQueryParams { + request: QueryVotesByVoterRequest; +} +export interface UseGroupsByMemberQuery extends ReactQueryParams { + request: QueryGroupsByMemberRequest; +} +export interface UseTallyResultQuery extends ReactQueryParams { + request: QueryTallyResultRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useGroupInfo = ({ + request, + options + }: UseGroupInfoQuery) => { + return useQuery(["groupInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupInfo(request); + }, options); + }; + + const useGroupPolicyInfo = ({ + request, + options + }: UseGroupPolicyInfoQuery) => { + return useQuery(["groupPolicyInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupPolicyInfo(request); + }, options); + }; + + const useGroupMembers = ({ + request, + options + }: UseGroupMembersQuery) => { + return useQuery(["groupMembersQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupMembers(request); + }, options); + }; + + const useGroupsByAdmin = ({ + request, + options + }: UseGroupsByAdminQuery) => { + return useQuery(["groupsByAdminQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupsByAdmin(request); + }, options); + }; + + const useGroupPoliciesByGroup = ({ + request, + options + }: UseGroupPoliciesByGroupQuery) => { + return useQuery(["groupPoliciesByGroupQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupPoliciesByGroup(request); + }, options); + }; + + const useGroupPoliciesByAdmin = ({ + request, + options + }: UseGroupPoliciesByAdminQuery) => { + return useQuery(["groupPoliciesByAdminQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupPoliciesByAdmin(request); + }, options); + }; + + const useProposal = ({ + request, + options + }: UseProposalQuery) => { + return useQuery(["proposalQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.proposal(request); + }, options); + }; + + const useProposalsByGroupPolicy = ({ + request, + options + }: UseProposalsByGroupPolicyQuery) => { + return useQuery(["proposalsByGroupPolicyQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.proposalsByGroupPolicy(request); + }, options); + }; + + const useVoteByProposalVoter = ({ + request, + options + }: UseVoteByProposalVoterQuery) => { + return useQuery(["voteByProposalVoterQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.voteByProposalVoter(request); + }, options); + }; + + const useVotesByProposal = ({ + request, + options + }: UseVotesByProposalQuery) => { + return useQuery(["votesByProposalQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.votesByProposal(request); + }, options); + }; + + const useVotesByVoter = ({ + request, + options + }: UseVotesByVoterQuery) => { + return useQuery(["votesByVoterQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.votesByVoter(request); + }, options); + }; + + const useGroupsByMember = ({ + request, + options + }: UseGroupsByMemberQuery) => { + return useQuery(["groupsByMemberQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.groupsByMember(request); + }, options); + }; + + const useTallyResult = ({ + request, + options + }: UseTallyResultQuery) => { + return useQuery(["tallyResultQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.tallyResult(request); + }, options); + }; + + return { + /** GroupInfo queries group info based on group id. */ + useGroupInfo, + + /** GroupPolicyInfo queries group policy info based on account address of group policy. */ + useGroupPolicyInfo, + + /** GroupMembers queries members of a group */ + useGroupMembers, + + /** GroupsByAdmin queries groups by admin address. */ + useGroupsByAdmin, + + /** GroupPoliciesByGroup queries group policies by group id. */ + useGroupPoliciesByGroup, + + /** GroupsByAdmin queries group policies by admin address. */ + useGroupPoliciesByAdmin, + + /** Proposal queries a proposal based on proposal id. */ + useProposal, + + /** ProposalsByGroupPolicy queries proposals based on account address of group policy. */ + useProposalsByGroupPolicy, + + /** VoteByProposalVoter queries a vote by proposal id and voter. */ + useVoteByProposalVoter, + + /** VotesByProposal queries a vote by proposal. */ + useVotesByProposal, + + /** VotesByVoter queries a vote by voter. */ + useVotesByVoter, + + /** GroupsByMember queries groups by member address. */ + useGroupsByMember, + + /** TallyResult queries the tally of a proposal votes. */ + useTallyResult + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/mint/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/mint/v1beta1/query.rpc.Query.ts similarity index 53% rename from __fixtures__/output1/cosmos/mint/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/mint/v1beta1/query.rpc.Query.ts index 60a158b498..fa1aec3dbe 100644 --- a/__fixtures__/output1/cosmos/mint/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/mint/v1beta1/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { Params, ParamsSDKType } from "./mint"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryInflationRequest, QueryInflationRequestSDKType, QueryInflationResponse, QueryInflationResponseSDKType, QueryAnnualProvisionsRequest, QueryAnnualProvisionsRequestSDKType, QueryAnnualProvisionsResponse, QueryAnnualProvisionsResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service. */ @@ -61,4 +63,74 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseInflationQuery extends ReactQueryParams { + request?: QueryInflationRequest; +} +export interface UseAnnualProvisionsQuery extends ReactQueryParams { + request?: QueryAnnualProvisionsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useInflation = ({ + request, + options + }: UseInflationQuery) => { + return useQuery(["inflationQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.inflation(request); + }, options); + }; + + const useAnnualProvisions = ({ + request, + options + }: UseAnnualProvisionsQuery) => { + return useQuery(["annualProvisionsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.annualProvisions(request); + }, options); + }; + + return { + /** Params returns the total set of minting parameters. */ + useParams, + + /** Inflation returns the current minting inflation value. */ + useInflation, + + /** AnnualProvisions current minting annual provisions value. */ + useAnnualProvisions + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/nft/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/nft/v1beta1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/cosmos/nft/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/nft/v1beta1/query.rpc.Query.ts index f65b9efac6..351108cb88 100644 --- a/__fixtures__/output1/cosmos/nft/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/nft/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { NFT, NFTSDKType, Class, ClassSDKType } from "./nft"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryBalanceRequest, QueryBalanceRequestSDKType, QueryBalanceResponse, QueryBalanceResponseSDKType, QueryOwnerRequest, QueryOwnerRequestSDKType, QueryOwnerResponse, QueryOwnerResponseSDKType, QuerySupplyRequest, QuerySupplyRequestSDKType, QuerySupplyResponse, QuerySupplyResponseSDKType, QueryNFTsRequest, QueryNFTsRequestSDKType, QueryNFTsResponse, QueryNFTsResponseSDKType, QueryNFTRequest, QueryNFTRequestSDKType, QueryNFTResponse, QueryNFTResponseSDKType, QueryClassRequest, QueryClassRequestSDKType, QueryClassResponse, QueryClassResponseSDKType, QueryClassesRequest, QueryClassesRequestSDKType, QueryClassesResponse, QueryClassesResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -123,4 +125,141 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseBalanceQuery extends ReactQueryParams { + request: QueryBalanceRequest; +} +export interface UseOwnerQuery extends ReactQueryParams { + request: QueryOwnerRequest; +} +export interface UseSupplyQuery extends ReactQueryParams { + request: QuerySupplyRequest; +} +export interface UseNFTsQuery extends ReactQueryParams { + request: QueryNFTsRequest; +} +export interface UseNFTQuery extends ReactQueryParams { + request: QueryNFTRequest; +} +export interface UseClassQuery extends ReactQueryParams { + request: QueryClassRequest; +} +export interface UseClassesQuery extends ReactQueryParams { + request?: QueryClassesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useBalance = ({ + request, + options + }: UseBalanceQuery) => { + return useQuery(["balanceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.balance(request); + }, options); + }; + + const useOwner = ({ + request, + options + }: UseOwnerQuery) => { + return useQuery(["ownerQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.owner(request); + }, options); + }; + + const useSupply = ({ + request, + options + }: UseSupplyQuery) => { + return useQuery(["supplyQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.supply(request); + }, options); + }; + + const useNFTs = ({ + request, + options + }: UseNFTsQuery) => { + return useQuery(["nFTsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.nFTs(request); + }, options); + }; + + const useNFT = ({ + request, + options + }: UseNFTQuery) => { + return useQuery(["nFTQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.nFT(request); + }, options); + }; + + const useClass = ({ + request, + options + }: UseClassQuery) => { + return useQuery(["classQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.class(request); + }, options); + }; + + const useClasses = ({ + request, + options + }: UseClassesQuery) => { + return useQuery(["classesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.classes(request); + }, options); + }; + + return { + /** Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 */ + useBalance, + + /** Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 */ + useOwner, + + /** Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. */ + useSupply, + + /** + * NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in + * ERC721Enumerable + */ + useNFTs, + + /** NFT queries an NFT based on its class and id. */ + useNFT, + + /** Class queries an NFT class based on its id */ + useClass, + + /** Classes queries all NFT classes */ + useClasses + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/params/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/params/v1beta1/query.rpc.Query.ts similarity index 51% rename from __fixtures__/output1/cosmos/params/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/params/v1beta1/query.rpc.Query.ts index 031d3f87d9..c530f3aa04 100644 --- a/__fixtures__/output1/cosmos/params/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/params/v1beta1/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { ParamChange, ParamChangeSDKType } from "./params"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QuerySubspacesRequest, QuerySubspacesRequestSDKType, QuerySubspacesResponse, QuerySubspacesResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -50,4 +52,61 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request: QueryParamsRequest; +} +export interface UseSubspacesQuery extends ReactQueryParams { + request?: QuerySubspacesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useSubspaces = ({ + request, + options + }: UseSubspacesQuery) => { + return useQuery(["subspacesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.subspaces(request); + }, options); + }; + + return { + /** + * Params queries a specific parameter of a module, given its subspace and + * key. + */ + useParams, + + /** Subspaces queries for all registered subspaces and all keys for a subspace. */ + useSubspaces + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/slashing/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/slashing/v1beta1/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/cosmos/slashing/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/slashing/v1beta1/query.rpc.Query.ts index 5d5e9ab9e2..eb0f11f079 100644 --- a/__fixtures__/output1/cosmos/slashing/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/slashing/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Params, ParamsSDKType, ValidatorSigningInfo, ValidatorSigningInfoSDKType } from "./slashing"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QuerySigningInfoRequest, QuerySigningInfoRequestSDKType, QuerySigningInfoResponse, QuerySigningInfoResponseSDKType, QuerySigningInfosRequest, QuerySigningInfosRequestSDKType, QuerySigningInfosResponse, QuerySigningInfosResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service */ @@ -64,4 +66,74 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseSigningInfoQuery extends ReactQueryParams { + request: QuerySigningInfoRequest; +} +export interface UseSigningInfosQuery extends ReactQueryParams { + request?: QuerySigningInfosRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useSigningInfo = ({ + request, + options + }: UseSigningInfoQuery) => { + return useQuery(["signingInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.signingInfo(request); + }, options); + }; + + const useSigningInfos = ({ + request, + options + }: UseSigningInfosQuery) => { + return useQuery(["signingInfosQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.signingInfos(request); + }, options); + }; + + return { + /** Params queries the parameters of slashing module */ + useParams, + + /** SigningInfo queries the signing info of given cons address */ + useSigningInfo, + + /** SigningInfos queries signing info of all validators */ + useSigningInfos + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/staking/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/staking/v1beta1/query.rpc.Query.ts similarity index 57% rename from __fixtures__/output1/cosmos/staking/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/staking/v1beta1/query.rpc.Query.ts index f6f77d5f97..661bc187ce 100644 --- a/__fixtures__/output1/cosmos/staking/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/staking/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Validator, ValidatorSDKType, DelegationResponse, DelegationResponseSDKType, UnbondingDelegation, UnbondingDelegationSDKType, RedelegationResponse, RedelegationResponseSDKType, HistoricalInfo, HistoricalInfoSDKType, Pool, PoolSDKType, Params, ParamsSDKType } from "./staking"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryValidatorsRequest, QueryValidatorsRequestSDKType, QueryValidatorsResponse, QueryValidatorsResponseSDKType, QueryValidatorRequest, QueryValidatorRequestSDKType, QueryValidatorResponse, QueryValidatorResponseSDKType, QueryValidatorDelegationsRequest, QueryValidatorDelegationsRequestSDKType, QueryValidatorDelegationsResponse, QueryValidatorDelegationsResponseSDKType, QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsRequestSDKType, QueryValidatorUnbondingDelegationsResponse, QueryValidatorUnbondingDelegationsResponseSDKType, QueryDelegationRequest, QueryDelegationRequestSDKType, QueryDelegationResponse, QueryDelegationResponseSDKType, QueryUnbondingDelegationRequest, QueryUnbondingDelegationRequestSDKType, QueryUnbondingDelegationResponse, QueryUnbondingDelegationResponseSDKType, QueryDelegatorDelegationsRequest, QueryDelegatorDelegationsRequestSDKType, QueryDelegatorDelegationsResponse, QueryDelegatorDelegationsResponseSDKType, QueryDelegatorUnbondingDelegationsRequest, QueryDelegatorUnbondingDelegationsRequestSDKType, QueryDelegatorUnbondingDelegationsResponse, QueryDelegatorUnbondingDelegationsResponseSDKType, QueryRedelegationsRequest, QueryRedelegationsRequestSDKType, QueryRedelegationsResponse, QueryRedelegationsResponseSDKType, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsRequestSDKType, QueryDelegatorValidatorsResponse, QueryDelegatorValidatorsResponseSDKType, QueryDelegatorValidatorRequest, QueryDelegatorValidatorRequestSDKType, QueryDelegatorValidatorResponse, QueryDelegatorValidatorResponseSDKType, QueryHistoricalInfoRequest, QueryHistoricalInfoRequestSDKType, QueryHistoricalInfoResponse, QueryHistoricalInfoResponseSDKType, QueryPoolRequest, QueryPoolRequestSDKType, QueryPoolResponse, QueryPoolResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -228,4 +230,262 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseValidatorsQuery extends ReactQueryParams { + request: QueryValidatorsRequest; +} +export interface UseValidatorQuery extends ReactQueryParams { + request: QueryValidatorRequest; +} +export interface UseValidatorDelegationsQuery extends ReactQueryParams { + request: QueryValidatorDelegationsRequest; +} +export interface UseValidatorUnbondingDelegationsQuery extends ReactQueryParams { + request: QueryValidatorUnbondingDelegationsRequest; +} +export interface UseDelegationQuery extends ReactQueryParams { + request: QueryDelegationRequest; +} +export interface UseUnbondingDelegationQuery extends ReactQueryParams { + request: QueryUnbondingDelegationRequest; +} +export interface UseDelegatorDelegationsQuery extends ReactQueryParams { + request: QueryDelegatorDelegationsRequest; +} +export interface UseDelegatorUnbondingDelegationsQuery extends ReactQueryParams { + request: QueryDelegatorUnbondingDelegationsRequest; +} +export interface UseRedelegationsQuery extends ReactQueryParams { + request: QueryRedelegationsRequest; +} +export interface UseDelegatorValidatorsQuery extends ReactQueryParams { + request: QueryDelegatorValidatorsRequest; +} +export interface UseDelegatorValidatorQuery extends ReactQueryParams { + request: QueryDelegatorValidatorRequest; +} +export interface UseHistoricalInfoQuery extends ReactQueryParams { + request: QueryHistoricalInfoRequest; +} +export interface UsePoolQuery extends ReactQueryParams { + request?: QueryPoolRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useValidators = ({ + request, + options + }: UseValidatorsQuery) => { + return useQuery(["validatorsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validators(request); + }, options); + }; + + const useValidator = ({ + request, + options + }: UseValidatorQuery) => { + return useQuery(["validatorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validator(request); + }, options); + }; + + const useValidatorDelegations = ({ + request, + options + }: UseValidatorDelegationsQuery) => { + return useQuery(["validatorDelegationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validatorDelegations(request); + }, options); + }; + + const useValidatorUnbondingDelegations = ({ + request, + options + }: UseValidatorUnbondingDelegationsQuery) => { + return useQuery(["validatorUnbondingDelegationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.validatorUnbondingDelegations(request); + }, options); + }; + + const useDelegation = ({ + request, + options + }: UseDelegationQuery) => { + return useQuery(["delegationQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegation(request); + }, options); + }; + + const useUnbondingDelegation = ({ + request, + options + }: UseUnbondingDelegationQuery) => { + return useQuery(["unbondingDelegationQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.unbondingDelegation(request); + }, options); + }; + + const useDelegatorDelegations = ({ + request, + options + }: UseDelegatorDelegationsQuery) => { + return useQuery(["delegatorDelegationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegatorDelegations(request); + }, options); + }; + + const useDelegatorUnbondingDelegations = ({ + request, + options + }: UseDelegatorUnbondingDelegationsQuery) => { + return useQuery(["delegatorUnbondingDelegationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegatorUnbondingDelegations(request); + }, options); + }; + + const useRedelegations = ({ + request, + options + }: UseRedelegationsQuery) => { + return useQuery(["redelegationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.redelegations(request); + }, options); + }; + + const useDelegatorValidators = ({ + request, + options + }: UseDelegatorValidatorsQuery) => { + return useQuery(["delegatorValidatorsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegatorValidators(request); + }, options); + }; + + const useDelegatorValidator = ({ + request, + options + }: UseDelegatorValidatorQuery) => { + return useQuery(["delegatorValidatorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.delegatorValidator(request); + }, options); + }; + + const useHistoricalInfo = ({ + request, + options + }: UseHistoricalInfoQuery) => { + return useQuery(["historicalInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.historicalInfo(request); + }, options); + }; + + const usePool = ({ + request, + options + }: UsePoolQuery) => { + return useQuery(["poolQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.pool(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + return { + /** Validators queries all validators that match the given status. */ + useValidators, + + /** Validator queries validator info for given validator address. */ + useValidator, + + /** ValidatorDelegations queries delegate info for given validator. */ + useValidatorDelegations, + + /** ValidatorUnbondingDelegations queries unbonding delegations of a validator. */ + useValidatorUnbondingDelegations, + + /** Delegation queries delegate info for given validator delegator pair. */ + useDelegation, + + /** + * UnbondingDelegation queries unbonding info for given validator delegator + * pair. + */ + useUnbondingDelegation, + + /** DelegatorDelegations queries all delegations of a given delegator address. */ + useDelegatorDelegations, + + /** + * DelegatorUnbondingDelegations queries all unbonding delegations of a given + * delegator address. + */ + useDelegatorUnbondingDelegations, + + /** Redelegations queries redelegations of given address. */ + useRedelegations, + + /** + * DelegatorValidators queries all validators info for given delegator + * address. + */ + useDelegatorValidators, + + /** + * DelegatorValidator queries validator info for given delegator validator + * pair. + */ + useDelegatorValidator, + + /** HistoricalInfo queries the historical info for given height. */ + useHistoricalInfo, + + /** Pool queries the pool info. */ + usePool, + + /** Parameters queries the staking parameters. */ + useParams + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.Service.ts b/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.Service.ts index 2f2cedc30a..35671e5aa5 100644 --- a/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.Service.ts +++ b/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.Service.ts @@ -5,7 +5,9 @@ import { BlockID, BlockIDSDKType } from "../../../tendermint/types/types"; import { Block, BlockSDKType } from "../../../tendermint/types/block"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { SimulateRequest, SimulateRequestSDKType, SimulateResponse, SimulateResponseSDKType, GetTxRequest, GetTxRequestSDKType, GetTxResponse, GetTxResponseSDKType, BroadcastTxRequest, BroadcastTxRequestSDKType, BroadcastTxResponse, BroadcastTxResponseSDKType, GetTxsEventRequest, GetTxsEventRequestSDKType, GetTxsEventResponse, GetTxsEventResponseSDKType, GetBlockWithTxsRequest, GetBlockWithTxsRequestSDKType, GetBlockWithTxsResponse, GetBlockWithTxsResponseSDKType } from "./service"; /** Service defines a gRPC service for interacting with transactions. */ @@ -97,4 +99,110 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseSimulateQuery extends ReactQueryParams { + request: SimulateRequest; +} +export interface UseGetTxQuery extends ReactQueryParams { + request: GetTxRequest; +} +export interface UseBroadcastTxQuery extends ReactQueryParams { + request: BroadcastTxRequest; +} +export interface UseGetTxsEventQuery extends ReactQueryParams { + request: GetTxsEventRequest; +} +export interface UseGetBlockWithTxsQuery extends ReactQueryParams { + request: GetBlockWithTxsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useSimulate = ({ + request, + options + }: UseSimulateQuery) => { + return useQuery(["simulateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.simulate(request); + }, options); + }; + + const useGetTx = ({ + request, + options + }: UseGetTxQuery) => { + return useQuery(["getTxQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getTx(request); + }, options); + }; + + const useBroadcastTx = ({ + request, + options + }: UseBroadcastTxQuery) => { + return useQuery(["broadcastTxQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.broadcastTx(request); + }, options); + }; + + const useGetTxsEvent = ({ + request, + options + }: UseGetTxsEventQuery) => { + return useQuery(["getTxsEventQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getTxsEvent(request); + }, options); + }; + + const useGetBlockWithTxs = ({ + request, + options + }: UseGetBlockWithTxsQuery) => { + return useQuery(["getBlockWithTxsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.getBlockWithTxs(request); + }, options); + }; + + return { + /** Simulate simulates executing a transaction for estimating gas usage. */ + useSimulate, + + /** GetTx fetches a tx by hash. */ + useGetTx, + + /** BroadcastTx broadcast transaction. */ + useBroadcastTx, + + /** GetTxsEvent fetches txs by event. */ + useGetTxsEvent, + + /** + * GetBlockWithTxs fetches a block with decoded txs. + * + * Since: cosmos-sdk 0.45.2 + */ + useGetBlockWithTxs + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.svc.ts b/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.svc.ts deleted file mode 100644 index 2f2cedc30a..0000000000 --- a/__fixtures__/output1/cosmos/tx/v1beta1/service.rpc.svc.ts +++ /dev/null @@ -1,100 +0,0 @@ -import { Tx, TxSDKType } from "./tx"; -import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../base/query/v1beta1/pagination"; -import { TxResponse, TxResponseSDKType, GasInfo, GasInfoSDKType, Result, ResultSDKType } from "../../base/abci/v1beta1/abci"; -import { BlockID, BlockIDSDKType } from "../../../tendermint/types/types"; -import { Block, BlockSDKType } from "../../../tendermint/types/block"; -import { Rpc } from "../../../helpers"; -import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; -import { SimulateRequest, SimulateRequestSDKType, SimulateResponse, SimulateResponseSDKType, GetTxRequest, GetTxRequestSDKType, GetTxResponse, GetTxResponseSDKType, BroadcastTxRequest, BroadcastTxRequestSDKType, BroadcastTxResponse, BroadcastTxResponseSDKType, GetTxsEventRequest, GetTxsEventRequestSDKType, GetTxsEventResponse, GetTxsEventResponseSDKType, GetBlockWithTxsRequest, GetBlockWithTxsRequestSDKType, GetBlockWithTxsResponse, GetBlockWithTxsResponseSDKType } from "./service"; - -/** Service defines a gRPC service for interacting with transactions. */ -export interface Service { - /** Simulate simulates executing a transaction for estimating gas usage. */ - simulate(request: SimulateRequest): Promise; - - /** GetTx fetches a tx by hash. */ - getTx(request: GetTxRequest): Promise; - - /** BroadcastTx broadcast transaction. */ - broadcastTx(request: BroadcastTxRequest): Promise; - - /** GetTxsEvent fetches txs by event. */ - getTxsEvent(request: GetTxsEventRequest): Promise; - - /** - * GetBlockWithTxs fetches a block with decoded txs. - * - * Since: cosmos-sdk 0.45.2 - */ - getBlockWithTxs(request: GetBlockWithTxsRequest): Promise; -} -export class ServiceClientImpl implements Service { - private readonly rpc: Rpc; - - constructor(rpc: Rpc) { - this.rpc = rpc; - this.simulate = this.simulate.bind(this); - this.getTx = this.getTx.bind(this); - this.broadcastTx = this.broadcastTx.bind(this); - this.getTxsEvent = this.getTxsEvent.bind(this); - this.getBlockWithTxs = this.getBlockWithTxs.bind(this); - } - - simulate(request: SimulateRequest): Promise { - const data = SimulateRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "Simulate", data); - return promise.then(data => SimulateResponse.decode(new _m0.Reader(data))); - } - - getTx(request: GetTxRequest): Promise { - const data = GetTxRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTx", data); - return promise.then(data => GetTxResponse.decode(new _m0.Reader(data))); - } - - broadcastTx(request: BroadcastTxRequest): Promise { - const data = BroadcastTxRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "BroadcastTx", data); - return promise.then(data => BroadcastTxResponse.decode(new _m0.Reader(data))); - } - - getTxsEvent(request: GetTxsEventRequest): Promise { - const data = GetTxsEventRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTxsEvent", data); - return promise.then(data => GetTxsEventResponse.decode(new _m0.Reader(data))); - } - - getBlockWithTxs(request: GetBlockWithTxsRequest): Promise { - const data = GetBlockWithTxsRequest.encode(request).finish(); - const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetBlockWithTxs", data); - return promise.then(data => GetBlockWithTxsResponse.decode(new _m0.Reader(data))); - } - -} -export const createRpcQueryExtension = (base: QueryClient) => { - const rpc = createProtobufRpcClient(base); - const queryService = new ServiceClientImpl(rpc); - return { - simulate(request: SimulateRequest): Promise { - return queryService.simulate(request); - }, - - getTx(request: GetTxRequest): Promise { - return queryService.getTx(request); - }, - - broadcastTx(request: BroadcastTxRequest): Promise { - return queryService.broadcastTx(request); - }, - - getTxsEvent(request: GetTxsEventRequest): Promise { - return queryService.getTxsEvent(request); - }, - - getBlockWithTxs(request: GetBlockWithTxsRequest): Promise { - return queryService.getBlockWithTxs(request); - } - - }; -}; \ No newline at end of file diff --git a/__fixtures__/output1/cosmos/upgrade/v1beta1/query.rpc.query.ts b/__fixtures__/output1/cosmos/upgrade/v1beta1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/cosmos/upgrade/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/cosmos/upgrade/v1beta1/query.rpc.Query.ts index e11f335a40..23a82b7c17 100644 --- a/__fixtures__/output1/cosmos/upgrade/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmos/upgrade/v1beta1/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { Plan, PlanSDKType, ModuleVersion, ModuleVersionSDKType } from "./upgrade"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryCurrentPlanRequest, QueryCurrentPlanRequestSDKType, QueryCurrentPlanResponse, QueryCurrentPlanResponseSDKType, QueryAppliedPlanRequest, QueryAppliedPlanRequestSDKType, QueryAppliedPlanResponse, QueryAppliedPlanResponseSDKType, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateRequestSDKType, QueryUpgradedConsensusStateResponse, QueryUpgradedConsensusStateResponseSDKType, QueryModuleVersionsRequest, QueryModuleVersionsRequestSDKType, QueryModuleVersionsResponse, QueryModuleVersionsResponseSDKType, QueryAuthorityRequest, QueryAuthorityRequestSDKType, QueryAuthorityResponse, QueryAuthorityResponseSDKType } from "./query"; /** Query defines the gRPC upgrade querier service. */ @@ -100,4 +102,117 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseCurrentPlanQuery extends ReactQueryParams { + request?: QueryCurrentPlanRequest; +} +export interface UseAppliedPlanQuery extends ReactQueryParams { + request: QueryAppliedPlanRequest; +} +export interface UseUpgradedConsensusStateQuery extends ReactQueryParams { + request: QueryUpgradedConsensusStateRequest; +} +export interface UseModuleVersionsQuery extends ReactQueryParams { + request: QueryModuleVersionsRequest; +} +export interface UseAuthorityQuery extends ReactQueryParams { + request?: QueryAuthorityRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useCurrentPlan = ({ + request, + options + }: UseCurrentPlanQuery) => { + return useQuery(["currentPlanQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.currentPlan(request); + }, options); + }; + + const useAppliedPlan = ({ + request, + options + }: UseAppliedPlanQuery) => { + return useQuery(["appliedPlanQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.appliedPlan(request); + }, options); + }; + + const useUpgradedConsensusState = ({ + request, + options + }: UseUpgradedConsensusStateQuery) => { + return useQuery(["upgradedConsensusStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.upgradedConsensusState(request); + }, options); + }; + + const useModuleVersions = ({ + request, + options + }: UseModuleVersionsQuery) => { + return useQuery(["moduleVersionsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleVersions(request); + }, options); + }; + + const useAuthority = ({ + request, + options + }: UseAuthorityQuery) => { + return useQuery(["authorityQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.authority(request); + }, options); + }; + + return { + /** CurrentPlan queries the current upgrade plan. */ + useCurrentPlan, + + /** AppliedPlan queries a previously applied upgrade plan by its name. */ + useAppliedPlan, + + /** + * UpgradedConsensusState queries the consensus state that will serve + * as a trusted kernel for the next version of this chain. It will only be + * stored at the last height of this chain. + * UpgradedConsensusState RPC not supported with legacy querier + * This rpc is deprecated now that IBC has its own replacement + * (https://github.com/cosmos/ibc-go/blob/2c880a22e9f9cc75f62b527ca94aa75ce1106001/proto/ibc/core/client/v1/query.proto#L54) + */ + useUpgradedConsensusState, + + /** + * ModuleVersions queries the list of module versions from state. + * + * Since: cosmos-sdk 0.43 + */ + useModuleVersions, + + /** Returns the account with authority to conduct upgrades */ + useAuthority + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/cosmwasm/wasm/v1/query.rpc.query.ts b/__fixtures__/output1/cosmwasm/wasm/v1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/cosmwasm/wasm/v1/query.rpc.query.ts rename to __fixtures__/output1/cosmwasm/wasm/v1/query.rpc.Query.ts index d8625e547e..b55ad74398 100644 --- a/__fixtures__/output1/cosmwasm/wasm/v1/query.rpc.query.ts +++ b/__fixtures__/output1/cosmwasm/wasm/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { ContractInfo, ContractInfoSDKType, ContractCodeHistoryEntry, ContractCodeHistoryEntrySDKType, Model, ModelSDKType } from "./types"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryContractInfoRequest, QueryContractInfoRequestSDKType, QueryContractInfoResponse, QueryContractInfoResponseSDKType, QueryContractHistoryRequest, QueryContractHistoryRequestSDKType, QueryContractHistoryResponse, QueryContractHistoryResponseSDKType, QueryContractsByCodeRequest, QueryContractsByCodeRequestSDKType, QueryContractsByCodeResponse, QueryContractsByCodeResponseSDKType, QueryAllContractStateRequest, QueryAllContractStateRequestSDKType, QueryAllContractStateResponse, QueryAllContractStateResponseSDKType, QueryRawContractStateRequest, QueryRawContractStateRequestSDKType, QueryRawContractStateResponse, QueryRawContractStateResponseSDKType, QuerySmartContractStateRequest, QuerySmartContractStateRequestSDKType, QuerySmartContractStateResponse, QuerySmartContractStateResponseSDKType, QueryCodeRequest, QueryCodeRequestSDKType, QueryCodeResponse, QueryCodeResponseSDKType, QueryCodesRequest, QueryCodesRequestSDKType, QueryCodesResponse, QueryCodesResponseSDKType, QueryPinnedCodesRequest, QueryPinnedCodesRequestSDKType, QueryPinnedCodesResponse, QueryPinnedCodesResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service */ @@ -150,4 +152,170 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseContractInfoQuery extends ReactQueryParams { + request: QueryContractInfoRequest; +} +export interface UseContractHistoryQuery extends ReactQueryParams { + request: QueryContractHistoryRequest; +} +export interface UseContractsByCodeQuery extends ReactQueryParams { + request: QueryContractsByCodeRequest; +} +export interface UseAllContractStateQuery extends ReactQueryParams { + request: QueryAllContractStateRequest; +} +export interface UseRawContractStateQuery extends ReactQueryParams { + request: QueryRawContractStateRequest; +} +export interface UseSmartContractStateQuery extends ReactQueryParams { + request: QuerySmartContractStateRequest; +} +export interface UseCodeQuery extends ReactQueryParams { + request: QueryCodeRequest; +} +export interface UseCodesQuery extends ReactQueryParams { + request?: QueryCodesRequest; +} +export interface UsePinnedCodesQuery extends ReactQueryParams { + request?: QueryPinnedCodesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useContractInfo = ({ + request, + options + }: UseContractInfoQuery) => { + return useQuery(["contractInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.contractInfo(request); + }, options); + }; + + const useContractHistory = ({ + request, + options + }: UseContractHistoryQuery) => { + return useQuery(["contractHistoryQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.contractHistory(request); + }, options); + }; + + const useContractsByCode = ({ + request, + options + }: UseContractsByCodeQuery) => { + return useQuery(["contractsByCodeQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.contractsByCode(request); + }, options); + }; + + const useAllContractState = ({ + request, + options + }: UseAllContractStateQuery) => { + return useQuery(["allContractStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allContractState(request); + }, options); + }; + + const useRawContractState = ({ + request, + options + }: UseRawContractStateQuery) => { + return useQuery(["rawContractStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.rawContractState(request); + }, options); + }; + + const useSmartContractState = ({ + request, + options + }: UseSmartContractStateQuery) => { + return useQuery(["smartContractStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.smartContractState(request); + }, options); + }; + + const useCode = ({ + request, + options + }: UseCodeQuery) => { + return useQuery(["codeQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.code(request); + }, options); + }; + + const useCodes = ({ + request, + options + }: UseCodesQuery) => { + return useQuery(["codesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.codes(request); + }, options); + }; + + const usePinnedCodes = ({ + request, + options + }: UsePinnedCodesQuery) => { + return useQuery(["pinnedCodesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.pinnedCodes(request); + }, options); + }; + + return { + /** ContractInfo gets the contract meta data */ + useContractInfo, + + /** ContractHistory gets the contract code history */ + useContractHistory, + + /** ContractsByCode lists all smart contracts for a code id */ + useContractsByCode, + + /** AllContractState gets all raw store data for a single contract */ + useAllContractState, + + /** RawContractState gets single key from the raw store data of a contract */ + useRawContractState, + + /** SmartContractState get smart query result from the contract */ + useSmartContractState, + + /** Code gets the binary code and metadata for a singe wasm code */ + useCode, + + /** Codes gets the metadata for all stored wasm codes */ + useCodes, + + /** PinnedCodes gets the pinned code ids */ + usePinnedCodes + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/claims/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/claims/v1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/evmos/claims/v1/query.rpc.query.ts rename to __fixtures__/output1/evmos/claims/v1/query.rpc.Query.ts index 5d4573a6d5..db8aabb90d 100644 --- a/__fixtures__/output1/evmos/claims/v1/query.rpc.query.ts +++ b/__fixtures__/output1/evmos/claims/v1/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { Params, ParamsSDKType } from "./genesis"; import { ClaimsRecordAddress, ClaimsRecordAddressSDKType, Claim, ClaimSDKType } from "./claims"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryTotalUnclaimedRequest, QueryTotalUnclaimedRequestSDKType, QueryTotalUnclaimedResponse, QueryTotalUnclaimedResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryClaimsRecordsRequest, QueryClaimsRecordsRequestSDKType, QueryClaimsRecordsResponse, QueryClaimsRecordsResponseSDKType, QueryClaimsRecordRequest, QueryClaimsRecordRequestSDKType, QueryClaimsRecordResponse, QueryClaimsRecordResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -80,4 +82,90 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseTotalUnclaimedQuery extends ReactQueryParams { + request?: QueryTotalUnclaimedRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseClaimsRecordsQuery extends ReactQueryParams { + request?: QueryClaimsRecordsRequest; +} +export interface UseClaimsRecordQuery extends ReactQueryParams { + request: QueryClaimsRecordRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useTotalUnclaimed = ({ + request, + options + }: UseTotalUnclaimedQuery) => { + return useQuery(["totalUnclaimedQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalUnclaimed(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useClaimsRecords = ({ + request, + options + }: UseClaimsRecordsQuery) => { + return useQuery(["claimsRecordsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.claimsRecords(request); + }, options); + }; + + const useClaimsRecord = ({ + request, + options + }: UseClaimsRecordQuery) => { + return useQuery(["claimsRecordQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.claimsRecord(request); + }, options); + }; + + return { + /** TotalUnclaimed queries the total unclaimed tokens from the airdrop */ + useTotalUnclaimed, + + /** Params returns the claims module parameters */ + useParams, + + /** ClaimsRecords returns all claims records */ + useClaimsRecords, + + /** ClaimsRecord returns the claims record for a given address */ + useClaimsRecord + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/epochs/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/epochs/v1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/evmos/epochs/v1/query.rpc.query.ts rename to __fixtures__/output1/evmos/epochs/v1/query.rpc.Query.ts index aa0ebc275a..6684ac35c7 100644 --- a/__fixtures__/output1/evmos/epochs/v1/query.rpc.query.ts +++ b/__fixtures__/output1/evmos/epochs/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { EpochInfo, EpochInfoSDKType } from "./genesis"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryEpochsInfoRequest, QueryEpochsInfoRequestSDKType, QueryEpochsInfoResponse, QueryEpochsInfoResponseSDKType, QueryCurrentEpochRequest, QueryCurrentEpochRequestSDKType, QueryCurrentEpochResponse, QueryCurrentEpochResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -50,4 +52,58 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseEpochInfosQuery extends ReactQueryParams { + request?: QueryEpochsInfoRequest; +} +export interface UseCurrentEpochQuery extends ReactQueryParams { + request: QueryCurrentEpochRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useEpochInfos = ({ + request, + options + }: UseEpochInfosQuery) => { + return useQuery(["epochInfosQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.epochInfos(request); + }, options); + }; + + const useCurrentEpoch = ({ + request, + options + }: UseCurrentEpochQuery) => { + return useQuery(["currentEpochQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.currentEpoch(request); + }, options); + }; + + return { + /** EpochInfos provide running epochInfos */ + useEpochInfos, + + /** CurrentEpoch provide current epoch of specified identifier */ + useCurrentEpoch + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/erc20/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/erc20/v1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/evmos/erc20/v1/query.rpc.query.ts rename to __fixtures__/output1/evmos/erc20/v1/query.rpc.Query.ts index 84932b0287..3002a8f38e 100644 --- a/__fixtures__/output1/evmos/erc20/v1/query.rpc.query.ts +++ b/__fixtures__/output1/evmos/erc20/v1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { TokenPair, TokenPairSDKType } from "./erc20"; import { Params, ParamsSDKType } from "./genesis"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryTokenPairsRequest, QueryTokenPairsRequestSDKType, QueryTokenPairsResponse, QueryTokenPairsResponseSDKType, QueryTokenPairRequest, QueryTokenPairRequestSDKType, QueryTokenPairResponse, QueryTokenPairResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -65,4 +67,74 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseTokenPairsQuery extends ReactQueryParams { + request?: QueryTokenPairsRequest; +} +export interface UseTokenPairQuery extends ReactQueryParams { + request: QueryTokenPairRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useTokenPairs = ({ + request, + options + }: UseTokenPairsQuery) => { + return useQuery(["tokenPairsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.tokenPairs(request); + }, options); + }; + + const useTokenPair = ({ + request, + options + }: UseTokenPairQuery) => { + return useQuery(["tokenPairQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.tokenPair(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + return { + /** TokenPairs retrieves registered token pairs */ + useTokenPairs, + + /** TokenPair retrieves a registered token pair */ + useTokenPair, + + /** Params retrieves the erc20 module params */ + useParams + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/fees/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/fees/v1/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/evmos/fees/v1/query.rpc.query.ts rename to __fixtures__/output1/evmos/fees/v1/query.rpc.Query.ts index 32efbef2e5..4ecbc88ffa 100644 --- a/__fixtures__/output1/evmos/fees/v1/query.rpc.query.ts +++ b/__fixtures__/output1/evmos/fees/v1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { DevFeeInfo, DevFeeInfoSDKType } from "./fees"; import { Params, ParamsSDKType } from "./genesis"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryDevFeeInfosRequest, QueryDevFeeInfosRequestSDKType, QueryDevFeeInfosResponse, QueryDevFeeInfosResponseSDKType, QueryDevFeeInfoRequest, QueryDevFeeInfoRequestSDKType, QueryDevFeeInfoResponse, QueryDevFeeInfoResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryDevFeeInfosPerDeployerRequest, QueryDevFeeInfosPerDeployerRequestSDKType, QueryDevFeeInfosPerDeployerResponse, QueryDevFeeInfosPerDeployerResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -82,4 +84,93 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseDevFeeInfosQuery extends ReactQueryParams { + request?: QueryDevFeeInfosRequest; +} +export interface UseDevFeeInfoQuery extends ReactQueryParams { + request: QueryDevFeeInfoRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseDevFeeInfosPerDeployerQuery extends ReactQueryParams { + request: QueryDevFeeInfosPerDeployerRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useDevFeeInfos = ({ + request, + options + }: UseDevFeeInfosQuery) => { + return useQuery(["devFeeInfosQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.devFeeInfos(request); + }, options); + }; + + const useDevFeeInfo = ({ + request, + options + }: UseDevFeeInfoQuery) => { + return useQuery(["devFeeInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.devFeeInfo(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useDevFeeInfosPerDeployer = ({ + request, + options + }: UseDevFeeInfosPerDeployerQuery) => { + return useQuery(["devFeeInfosPerDeployerQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.devFeeInfosPerDeployer(request); + }, options); + }; + + return { + /** DevFeeInfos retrieves all registered contracts for fee distribution */ + useDevFeeInfos, + + /** DevFeeInfo retrieves a registered contract for fee distribution */ + useDevFeeInfo, + + /** Params retrieves the fees module params */ + useParams, + + /** + * DevFeeInfosPerDeployer retrieves all contracts that a deployer has + * registered for fee distribution + */ + useDevFeeInfosPerDeployer + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/incentives/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/incentives/v1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/evmos/incentives/v1/query.rpc.query.ts rename to __fixtures__/output1/evmos/incentives/v1/query.rpc.Query.ts index 533db02d46..3bc7d3cfa9 100644 --- a/__fixtures__/output1/evmos/incentives/v1/query.rpc.query.ts +++ b/__fixtures__/output1/evmos/incentives/v1/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { DecCoin, DecCoinSDKType } from "../../../cosmos/base/v1beta1/coin"; import { Params, ParamsSDKType } from "./genesis"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryIncentivesRequest, QueryIncentivesRequestSDKType, QueryIncentivesResponse, QueryIncentivesResponseSDKType, QueryIncentiveRequest, QueryIncentiveRequestSDKType, QueryIncentiveResponse, QueryIncentiveResponseSDKType, QueryGasMetersRequest, QueryGasMetersRequestSDKType, QueryGasMetersResponse, QueryGasMetersResponseSDKType, QueryGasMeterRequest, QueryGasMeterRequestSDKType, QueryGasMeterResponse, QueryGasMeterResponseSDKType, QueryAllocationMetersRequest, QueryAllocationMetersRequestSDKType, QueryAllocationMetersResponse, QueryAllocationMetersResponseSDKType, QueryAllocationMeterRequest, QueryAllocationMeterRequestSDKType, QueryAllocationMeterResponse, QueryAllocationMeterResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -127,4 +129,141 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseIncentivesQuery extends ReactQueryParams { + request?: QueryIncentivesRequest; +} +export interface UseIncentiveQuery extends ReactQueryParams { + request: QueryIncentiveRequest; +} +export interface UseGasMetersQuery extends ReactQueryParams { + request: QueryGasMetersRequest; +} +export interface UseGasMeterQuery extends ReactQueryParams { + request: QueryGasMeterRequest; +} +export interface UseAllocationMetersQuery extends ReactQueryParams { + request?: QueryAllocationMetersRequest; +} +export interface UseAllocationMeterQuery extends ReactQueryParams { + request: QueryAllocationMeterRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useIncentives = ({ + request, + options + }: UseIncentivesQuery) => { + return useQuery(["incentivesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.incentives(request); + }, options); + }; + + const useIncentive = ({ + request, + options + }: UseIncentiveQuery) => { + return useQuery(["incentiveQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.incentive(request); + }, options); + }; + + const useGasMeters = ({ + request, + options + }: UseGasMetersQuery) => { + return useQuery(["gasMetersQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.gasMeters(request); + }, options); + }; + + const useGasMeter = ({ + request, + options + }: UseGasMeterQuery) => { + return useQuery(["gasMeterQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.gasMeter(request); + }, options); + }; + + const useAllocationMeters = ({ + request, + options + }: UseAllocationMetersQuery) => { + return useQuery(["allocationMetersQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allocationMeters(request); + }, options); + }; + + const useAllocationMeter = ({ + request, + options + }: UseAllocationMeterQuery) => { + return useQuery(["allocationMeterQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allocationMeter(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + return { + /** Incentives retrieves registered incentives */ + useIncentives, + + /** Incentive retrieves a registered incentive */ + useIncentive, + + /** GasMeters retrieves active gas meters for a given contract */ + useGasMeters, + + /** GasMeter Retrieves a active gas meter */ + useGasMeter, + + /** + * AllocationMeters retrieves active allocation meters for a given + * denomination + */ + useAllocationMeters, + + /** AllocationMeter Retrieves a active gas meter */ + useAllocationMeter, + + /** Params retrieves the incentives module params */ + useParams + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/inflation/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/inflation/v1/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/evmos/inflation/v1/query.rpc.query.ts rename to __fixtures__/output1/evmos/inflation/v1/query.rpc.Query.ts index 2e7ef07a3d..c9d9580091 100644 --- a/__fixtures__/output1/evmos/inflation/v1/query.rpc.query.ts +++ b/__fixtures__/output1/evmos/inflation/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { DecCoin, DecCoinSDKType } from "../../../cosmos/base/v1beta1/coin"; import { Params, ParamsSDKType } from "./genesis"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryPeriodRequest, QueryPeriodRequestSDKType, QueryPeriodResponse, QueryPeriodResponseSDKType, QueryEpochMintProvisionRequest, QueryEpochMintProvisionRequestSDKType, QueryEpochMintProvisionResponse, QueryEpochMintProvisionResponseSDKType, QuerySkippedEpochsRequest, QuerySkippedEpochsRequestSDKType, QuerySkippedEpochsResponse, QuerySkippedEpochsResponseSDKType, QueryCirculatingSupplyRequest, QueryCirculatingSupplyRequestSDKType, QueryCirculatingSupplyResponse, QueryCirculatingSupplyResponseSDKType, QueryInflationRateRequest, QueryInflationRateRequestSDKType, QueryInflationRateResponse, QueryInflationRateResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service. */ @@ -107,4 +109,125 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UsePeriodQuery extends ReactQueryParams { + request?: QueryPeriodRequest; +} +export interface UseEpochMintProvisionQuery extends ReactQueryParams { + request?: QueryEpochMintProvisionRequest; +} +export interface UseSkippedEpochsQuery extends ReactQueryParams { + request?: QuerySkippedEpochsRequest; +} +export interface UseCirculatingSupplyQuery extends ReactQueryParams { + request?: QueryCirculatingSupplyRequest; +} +export interface UseInflationRateQuery extends ReactQueryParams { + request?: QueryInflationRateRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const usePeriod = ({ + request, + options + }: UsePeriodQuery) => { + return useQuery(["periodQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.period(request); + }, options); + }; + + const useEpochMintProvision = ({ + request, + options + }: UseEpochMintProvisionQuery) => { + return useQuery(["epochMintProvisionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.epochMintProvision(request); + }, options); + }; + + const useSkippedEpochs = ({ + request, + options + }: UseSkippedEpochsQuery) => { + return useQuery(["skippedEpochsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.skippedEpochs(request); + }, options); + }; + + const useCirculatingSupply = ({ + request, + options + }: UseCirculatingSupplyQuery) => { + return useQuery(["circulatingSupplyQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.circulatingSupply(request); + }, options); + }; + + const useInflationRate = ({ + request, + options + }: UseInflationRateQuery) => { + return useQuery(["inflationRateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.inflationRate(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + return { + /** Period retrieves current period. */ + usePeriod, + + /** EpochMintProvision retrieves current minting epoch provision value. */ + useEpochMintProvision, + + /** SkippedEpochs retrieves the total number of skipped epochs. */ + useSkippedEpochs, + + /** + * CirculatingSupply retrieves the total number of tokens that are in + * circulation (i.e. excluding unvested tokens). + */ + useCirculatingSupply, + + /** InflationRate retrieves the inflation rate of the current period. */ + useInflationRate, + + /** Params retrieves the total set of minting parameters. */ + useParams + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/recovery/v1/query.rpc.Query.ts b/__fixtures__/output1/evmos/recovery/v1/query.rpc.Query.ts new file mode 100644 index 0000000000..dfdf2ede04 --- /dev/null +++ b/__fixtures__/output1/evmos/recovery/v1/query.rpc.Query.ts @@ -0,0 +1,76 @@ +import { Params, ParamsSDKType } from "./genesis"; +import { Rpc } from "../../../helpers"; +import * as _m0 from "protobufjs/minimal"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; +import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; + +/** Query defines the gRPC querier service. */ +export interface Query { + /** Params retrieves the total set of recovery parameters. */ + params(request?: QueryParamsRequest): Promise; +} +export class QueryClientImpl implements Query { + private readonly rpc: Rpc; + + constructor(rpc: Rpc) { + this.rpc = rpc; + this.params = this.params.bind(this); + } + + params(request: QueryParamsRequest = {}): Promise { + const data = QueryParamsRequest.encode(request).finish(); + const promise = this.rpc.request("evmos.recovery.v1.Query", "Params", data); + return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data))); + } + +} +export const createRpcQueryExtension = (base: QueryClient) => { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + return { + params(request?: QueryParamsRequest): Promise { + return queryService.params(request); + } + + }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + return { + /** Params retrieves the total set of recovery parameters. */ + useParams + }; +}; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/recovery/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/recovery/v1/query.rpc.query.ts deleted file mode 100644 index 84ab102f83..0000000000 --- a/__fixtures__/output1/evmos/recovery/v1/query.rpc.query.ts +++ /dev/null @@ -1,36 +0,0 @@ -import { Params, ParamsSDKType } from "./genesis"; -import { Rpc } from "../../../helpers"; -import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; -import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; - -/** Query defines the gRPC querier service. */ -export interface Query { - /** Params retrieves the total set of recovery parameters. */ - params(request?: QueryParamsRequest): Promise; -} -export class QueryClientImpl implements Query { - private readonly rpc: Rpc; - - constructor(rpc: Rpc) { - this.rpc = rpc; - this.params = this.params.bind(this); - } - - params(request: QueryParamsRequest = {}): Promise { - const data = QueryParamsRequest.encode(request).finish(); - const promise = this.rpc.request("evmos.recovery.v1.Query", "Params", data); - return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data))); - } - -} -export const createRpcQueryExtension = (base: QueryClient) => { - const rpc = createProtobufRpcClient(base); - const queryService = new QueryClientImpl(rpc); - return { - params(request?: QueryParamsRequest): Promise { - return queryService.params(request); - } - - }; -}; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/vesting/v1/query.rpc.Query.ts b/__fixtures__/output1/evmos/vesting/v1/query.rpc.Query.ts new file mode 100644 index 0000000000..bd95e1ab08 --- /dev/null +++ b/__fixtures__/output1/evmos/vesting/v1/query.rpc.Query.ts @@ -0,0 +1,76 @@ +import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin"; +import { Rpc } from "../../../helpers"; +import * as _m0 from "protobufjs/minimal"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; +import { QueryBalancesRequest, QueryBalancesRequestSDKType, QueryBalancesResponse, QueryBalancesResponseSDKType } from "./query"; + +/** Query defines the gRPC querier service. */ +export interface Query { + /** Retrieves the unvested, vested and locked tokens for a vesting account */ + balances(request: QueryBalancesRequest): Promise; +} +export class QueryClientImpl implements Query { + private readonly rpc: Rpc; + + constructor(rpc: Rpc) { + this.rpc = rpc; + this.balances = this.balances.bind(this); + } + + balances(request: QueryBalancesRequest): Promise { + const data = QueryBalancesRequest.encode(request).finish(); + const promise = this.rpc.request("evmos.vesting.v1.Query", "Balances", data); + return promise.then(data => QueryBalancesResponse.decode(new _m0.Reader(data))); + } + +} +export const createRpcQueryExtension = (base: QueryClient) => { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + return { + balances(request: QueryBalancesRequest): Promise { + return queryService.balances(request); + } + + }; +}; +export interface UseBalancesQuery extends ReactQueryParams { + request: QueryBalancesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useBalances = ({ + request, + options + }: UseBalancesQuery) => { + return useQuery(["balancesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.balances(request); + }, options); + }; + + return { + /** Retrieves the unvested, vested and locked tokens for a vesting account */ + useBalances + }; +}; \ No newline at end of file diff --git a/__fixtures__/output1/evmos/vesting/v1/query.rpc.query.ts b/__fixtures__/output1/evmos/vesting/v1/query.rpc.query.ts deleted file mode 100644 index feb54ff72b..0000000000 --- a/__fixtures__/output1/evmos/vesting/v1/query.rpc.query.ts +++ /dev/null @@ -1,36 +0,0 @@ -import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin"; -import { Rpc } from "../../../helpers"; -import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; -import { QueryBalancesRequest, QueryBalancesRequestSDKType, QueryBalancesResponse, QueryBalancesResponseSDKType } from "./query"; - -/** Query defines the gRPC querier service. */ -export interface Query { - /** Retrieves the unvested, vested and locked tokens for a vesting account */ - balances(request: QueryBalancesRequest): Promise; -} -export class QueryClientImpl implements Query { - private readonly rpc: Rpc; - - constructor(rpc: Rpc) { - this.rpc = rpc; - this.balances = this.balances.bind(this); - } - - balances(request: QueryBalancesRequest): Promise { - const data = QueryBalancesRequest.encode(request).finish(); - const promise = this.rpc.request("evmos.vesting.v1.Query", "Balances", data); - return promise.then(data => QueryBalancesResponse.decode(new _m0.Reader(data))); - } - -} -export const createRpcQueryExtension = (base: QueryClient) => { - const rpc = createProtobufRpcClient(base); - const queryService = new QueryClientImpl(rpc); - return { - balances(request: QueryBalancesRequest): Promise { - return queryService.balances(request); - } - - }; -}; \ No newline at end of file diff --git a/__fixtures__/output1/extern.ts b/__fixtures__/output1/extern.ts new file mode 100644 index 0000000000..6151f35099 --- /dev/null +++ b/__fixtures__/output1/extern.ts @@ -0,0 +1,33 @@ +/** +* This file and any referenced files were automatically generated by @osmonauts/telescope@latest +* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain +* and run the transpile command or yarn proto command to regenerate this bundle. +*/ + +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from '@cosmjs/stargate' +import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc"; + +const _rpcClients: Record = {}; + +export const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => { + if (typeof rpcEndpoint === 'string') { + return rpcEndpoint; + } else if (!!rpcEndpoint) { + //@ts-ignore + return rpcEndpoint.url; + } +} + +export const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => { + const key = getRpcEndpointKey(rpcEndpoint); + if (!key) return; + if (_rpcClients.hasOwnProperty(key)) { + return _rpcClients[key]; + } + const tmClient = await Tendermint34Client.connect(rpcEndpoint); + //@ts-ignore + const client = new QueryClient(tmClient); + const rpc = createProtobufRpcClient(client); + _rpcClients[key] = rpc; + return rpc; +} diff --git a/__fixtures__/output1/helpers.ts b/__fixtures__/output1/helpers.ts index 159ae4d6d2..84f59a3588 100644 --- a/__fixtures__/output1/helpers.ts +++ b/__fixtures__/output1/helpers.ts @@ -1,9 +1,9 @@ /** - * This file and any referenced files were automatically generated by @osmonauts/telescope@latest - * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain - * and run the transpile command or yarn proto command to regenerate this bundle. - */ - +* This file and any referenced files were automatically generated by @osmonauts/telescope@latest +* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain +* and run the transpile command or yarn proto command to regenerate this bundle. +*/ + import * as _m0 from "protobufjs/minimal"; import Long from 'long'; diff --git a/__fixtures__/output1/hooks.ts b/__fixtures__/output1/hooks.ts new file mode 100644 index 0000000000..8eac9873a1 --- /dev/null +++ b/__fixtures__/output1/hooks.ts @@ -0,0 +1,231 @@ +import { ProtobufRpcClient } from "@cosmjs/stargate"; +import * as _AkashAuditV1beta2Queryrpc from "./akash/audit/v1beta2/query.rpc.Query"; +import * as _AkashCertV1beta2Queryrpc from "./akash/cert/v1beta2/query.rpc.Query"; +import * as _AkashDeploymentV1beta2Queryrpc from "./akash/deployment/v1beta2/query.rpc.Query"; +import * as _AkashEscrowV1beta1Queryrpc from "./akash/escrow/v1beta1/query.rpc.Query"; +import * as _AkashEscrowV1beta2Queryrpc from "./akash/escrow/v1beta2/query.rpc.Query"; +import * as _AkashMarketV1beta2Queryrpc from "./akash/market/v1beta2/query.rpc.Query"; +import * as _AkashProviderV1beta2Queryrpc from "./akash/provider/v1beta2/query.rpc.Query"; +import * as _CosmosAppV1alpha1Queryrpc from "./cosmos/app/v1alpha1/query.rpc.Query"; +import * as _CosmosAuthV1beta1Queryrpc from "./cosmos/auth/v1beta1/query.rpc.Query"; +import * as _CosmosAuthzV1beta1Queryrpc from "./cosmos/authz/v1beta1/query.rpc.Query"; +import * as _CosmosBankV1beta1Queryrpc from "./cosmos/bank/v1beta1/query.rpc.Query"; +import * as _CosmosBaseReflectionV1beta1Reflectionrpc from "./cosmos/base/reflection/v1beta1/reflection.rpc.ReflectionService"; +import * as _CosmosBaseReflectionV2alpha1Reflectionrpc from "./cosmos/base/reflection/v2alpha1/reflection.rpc.ReflectionService"; +import * as _CosmosBaseTendermintV1beta1Queryrpc from "./cosmos/base/tendermint/v1beta1/query.rpc.Service"; +import * as _CosmosDistributionV1beta1Queryrpc from "./cosmos/distribution/v1beta1/query.rpc.Query"; +import * as _CosmosEvidenceV1beta1Queryrpc from "./cosmos/evidence/v1beta1/query.rpc.Query"; +import * as _CosmosFeegrantV1beta1Queryrpc from "./cosmos/feegrant/v1beta1/query.rpc.Query"; +import * as _CosmosGovV1Queryrpc from "./cosmos/gov/v1/query.rpc.Query"; +import * as _CosmosGovV1beta1Queryrpc from "./cosmos/gov/v1beta1/query.rpc.Query"; +import * as _CosmosGroupV1Queryrpc from "./cosmos/group/v1/query.rpc.Query"; +import * as _CosmosMintV1beta1Queryrpc from "./cosmos/mint/v1beta1/query.rpc.Query"; +import * as _CosmosNftV1beta1Queryrpc from "./cosmos/nft/v1beta1/query.rpc.Query"; +import * as _CosmosParamsV1beta1Queryrpc from "./cosmos/params/v1beta1/query.rpc.Query"; +import * as _CosmosSlashingV1beta1Queryrpc from "./cosmos/slashing/v1beta1/query.rpc.Query"; +import * as _CosmosStakingV1beta1Queryrpc from "./cosmos/staking/v1beta1/query.rpc.Query"; +import * as _CosmosTxV1beta1Servicerpc from "./cosmos/tx/v1beta1/service.rpc.Service"; +import * as _CosmosUpgradeV1beta1Queryrpc from "./cosmos/upgrade/v1beta1/query.rpc.Query"; +import * as _CosmwasmWasmV1Queryrpc from "./cosmwasm/wasm/v1/query.rpc.Query"; +import * as _EvmosClaimsV1Queryrpc from "./evmos/claims/v1/query.rpc.Query"; +import * as _EvmosEpochsV1Queryrpc from "./evmos/epochs/v1/query.rpc.Query"; +import * as _EvmosErc20V1Queryrpc from "./evmos/erc20/v1/query.rpc.Query"; +import * as _EvmosFeesV1Queryrpc from "./evmos/fees/v1/query.rpc.Query"; +import * as _EvmosIncentivesV1Queryrpc from "./evmos/incentives/v1/query.rpc.Query"; +import * as _EvmosInflationV1Queryrpc from "./evmos/inflation/v1/query.rpc.Query"; +import * as _EvmosRecoveryV1Queryrpc from "./evmos/recovery/v1/query.rpc.Query"; +import * as _EvmosVestingV1Queryrpc from "./evmos/vesting/v1/query.rpc.Query"; +import * as _IbcApplicationsTransferV1Queryrpc from "./ibc/applications/transfer/v1/query.rpc.Query"; +import * as _IbcCoreChannelV1Queryrpc from "./ibc/core/channel/v1/query.rpc.Query"; +import * as _IbcCoreClientV1Queryrpc from "./ibc/core/client/v1/query.rpc.Query"; +import * as _IbcCoreConnectionV1Queryrpc from "./ibc/core/connection/v1/query.rpc.Query"; +import * as _IbcCorePortV1Queryrpc from "./ibc/core/port/v1/query.rpc.Query"; +import * as _OsmosisClaimV1beta1Queryrpc from "./osmosis/claim/v1beta1/query.rpc.Query"; +import * as _OsmosisEpochsQueryrpc from "./osmosis/epochs/query.rpc.Query"; +import * as _OsmosisGammV1beta1Queryrpc from "./osmosis/gamm/v1beta1/query.rpc.Query"; +import * as _OsmosisIncentivesQueryrpc from "./osmosis/incentives/query.rpc.Query"; +import * as _OsmosisLockupQueryrpc from "./osmosis/lockup/query.rpc.Query"; +import * as _OsmosisMintV1beta1Queryrpc from "./osmosis/mint/v1beta1/query.rpc.Query"; +import * as _OsmosisPoolincentivesV1beta1Queryrpc from "./osmosis/pool-incentives/v1beta1/query.rpc.Query"; +import * as _OsmosisStreamswapV1Queryrpc from "./osmosis/streamswap/v1/query.rpc.Query"; +import * as _OsmosisSuperfluidQueryrpc from "./osmosis/superfluid/query.rpc.Query"; +import * as _OsmosisTokenfactoryV1beta1Queryrpc from "./osmosis/tokenfactory/v1beta1/query.rpc.Query"; +import * as _OsmosisTwapV1beta1Queryrpc from "./osmosis/twap/v1beta1/query.rpc.Query"; +import * as _OsmosisTxfeesV1beta1Queryrpc from "./osmosis/txfees/v1beta1/query.rpc.Query"; +import * as _TendermintAbciTypesrpc from "./tendermint/abci/types.rpc.ABCIApplication"; +export const createRpcQueryHooks = ({ + rpc +}: { + rpc: ProtobufRpcClient | undefined; +}) => { + return { + akash: { + audit: { + v1beta2: _AkashAuditV1beta2Queryrpc.createRpcQueryHooks(rpc) + }, + cert: { + v1beta2: _AkashCertV1beta2Queryrpc.createRpcQueryHooks(rpc) + }, + deployment: { + v1beta2: _AkashDeploymentV1beta2Queryrpc.createRpcQueryHooks(rpc) + }, + escrow: { + v1beta1: _AkashEscrowV1beta1Queryrpc.createRpcQueryHooks(rpc), + v1beta2: _AkashEscrowV1beta2Queryrpc.createRpcQueryHooks(rpc) + }, + market: { + v1beta2: _AkashMarketV1beta2Queryrpc.createRpcQueryHooks(rpc) + }, + provider: { + v1beta2: _AkashProviderV1beta2Queryrpc.createRpcQueryHooks(rpc) + } + }, + cosmos: { + app: { + v1alpha1: _CosmosAppV1alpha1Queryrpc.createRpcQueryHooks(rpc) + }, + auth: { + v1beta1: _CosmosAuthV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + authz: { + v1beta1: _CosmosAuthzV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + bank: { + v1beta1: _CosmosBankV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + base: { + reflection: { + v1beta1: _CosmosBaseReflectionV1beta1Reflectionrpc.createRpcQueryHooks(rpc), + v2alpha1: _CosmosBaseReflectionV2alpha1Reflectionrpc.createRpcQueryHooks(rpc) + }, + tendermint: { + v1beta1: _CosmosBaseTendermintV1beta1Queryrpc.createRpcQueryHooks(rpc) + } + }, + distribution: { + v1beta1: _CosmosDistributionV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + evidence: { + v1beta1: _CosmosEvidenceV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + feegrant: { + v1beta1: _CosmosFeegrantV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + gov: { + v1: _CosmosGovV1Queryrpc.createRpcQueryHooks(rpc), + v1beta1: _CosmosGovV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + group: { + v1: _CosmosGroupV1Queryrpc.createRpcQueryHooks(rpc) + }, + mint: { + v1beta1: _CosmosMintV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + nft: { + v1beta1: _CosmosNftV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + params: { + v1beta1: _CosmosParamsV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + slashing: { + v1beta1: _CosmosSlashingV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + staking: { + v1beta1: _CosmosStakingV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + tx: { + v1beta1: _CosmosTxV1beta1Servicerpc.createRpcQueryHooks(rpc) + }, + upgrade: { + v1beta1: _CosmosUpgradeV1beta1Queryrpc.createRpcQueryHooks(rpc) + } + }, + cosmwasm: { + wasm: { + v1: _CosmwasmWasmV1Queryrpc.createRpcQueryHooks(rpc) + } + }, + evmos: { + claims: { + v1: _EvmosClaimsV1Queryrpc.createRpcQueryHooks(rpc) + }, + epochs: { + v1: _EvmosEpochsV1Queryrpc.createRpcQueryHooks(rpc) + }, + erc20: { + v1: _EvmosErc20V1Queryrpc.createRpcQueryHooks(rpc) + }, + fees: { + v1: _EvmosFeesV1Queryrpc.createRpcQueryHooks(rpc) + }, + incentives: { + v1: _EvmosIncentivesV1Queryrpc.createRpcQueryHooks(rpc) + }, + inflation: { + v1: _EvmosInflationV1Queryrpc.createRpcQueryHooks(rpc) + }, + recovery: { + v1: _EvmosRecoveryV1Queryrpc.createRpcQueryHooks(rpc) + }, + vesting: { + v1: _EvmosVestingV1Queryrpc.createRpcQueryHooks(rpc) + } + }, + ibc: { + applications: { + transfer: { + v1: _IbcApplicationsTransferV1Queryrpc.createRpcQueryHooks(rpc) + } + }, + core: { + channel: { + v1: _IbcCoreChannelV1Queryrpc.createRpcQueryHooks(rpc) + }, + client: { + v1: _IbcCoreClientV1Queryrpc.createRpcQueryHooks(rpc) + }, + connection: { + v1: _IbcCoreConnectionV1Queryrpc.createRpcQueryHooks(rpc) + }, + port: { + v1: _IbcCorePortV1Queryrpc.createRpcQueryHooks(rpc) + } + } + }, + osmosis: { + claim: { + v1beta1: _OsmosisClaimV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + epochs: { + v1beta1: _OsmosisEpochsQueryrpc.createRpcQueryHooks(rpc) + }, + gamm: { + v1beta1: _OsmosisGammV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + incentives: _OsmosisIncentivesQueryrpc.createRpcQueryHooks(rpc), + lockup: _OsmosisLockupQueryrpc.createRpcQueryHooks(rpc), + mint: { + v1beta1: _OsmosisMintV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + poolincentives: { + v1beta1: _OsmosisPoolincentivesV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + streamswap: { + v1: _OsmosisStreamswapV1Queryrpc.createRpcQueryHooks(rpc) + }, + superfluid: _OsmosisSuperfluidQueryrpc.createRpcQueryHooks(rpc), + tokenfactory: { + v1beta1: _OsmosisTokenfactoryV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + twap: { + v1beta1: _OsmosisTwapV1beta1Queryrpc.createRpcQueryHooks(rpc) + }, + txfees: { + v1beta1: _OsmosisTxfeesV1beta1Queryrpc.createRpcQueryHooks(rpc) + } + }, + tendermint: { + abci: _TendermintAbciTypesrpc.createRpcQueryHooks(rpc) + } + }; +}; \ No newline at end of file diff --git a/__fixtures__/output1/ibc/applications/transfer/v1/query.rpc.query.ts b/__fixtures__/output1/ibc/applications/transfer/v1/query.rpc.Query.ts similarity index 55% rename from __fixtures__/output1/ibc/applications/transfer/v1/query.rpc.query.ts rename to __fixtures__/output1/ibc/applications/transfer/v1/query.rpc.Query.ts index 93ab7ec57b..f44e86eeaf 100644 --- a/__fixtures__/output1/ibc/applications/transfer/v1/query.rpc.query.ts +++ b/__fixtures__/output1/ibc/applications/transfer/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { DenomTrace, DenomTraceSDKType, Params, ParamsSDKType } from "./transfer"; import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryDenomTraceRequest, QueryDenomTraceRequestSDKType, QueryDenomTraceResponse, QueryDenomTraceResponseSDKType, QueryDenomTracesRequest, QueryDenomTracesRequestSDKType, QueryDenomTracesResponse, QueryDenomTracesResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service. */ @@ -64,4 +66,74 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseDenomTraceQuery extends ReactQueryParams { + request: QueryDenomTraceRequest; +} +export interface UseDenomTracesQuery extends ReactQueryParams { + request?: QueryDenomTracesRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useDenomTrace = ({ + request, + options + }: UseDenomTraceQuery) => { + return useQuery(["denomTraceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomTrace(request); + }, options); + }; + + const useDenomTraces = ({ + request, + options + }: UseDenomTracesQuery) => { + return useQuery(["denomTracesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomTraces(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + return { + /** DenomTrace queries a denomination trace information. */ + useDenomTrace, + + /** DenomTraces queries all denomination traces. */ + useDenomTraces, + + /** Params queries all parameters of the ibc-transfer module. */ + useParams + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/ibc/core/channel/v1/query.rpc.query.ts b/__fixtures__/output1/ibc/core/channel/v1/query.rpc.Query.ts similarity index 57% rename from __fixtures__/output1/ibc/core/channel/v1/query.rpc.query.ts rename to __fixtures__/output1/ibc/core/channel/v1/query.rpc.Query.ts index bd2f47e948..25735ac68c 100644 --- a/__fixtures__/output1/ibc/core/channel/v1/query.rpc.query.ts +++ b/__fixtures__/output1/ibc/core/channel/v1/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { Height, HeightSDKType, IdentifiedClientState, IdentifiedClientStateSDKT import { Any, AnySDKType } from "../../../../google/protobuf/any"; import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryChannelRequest, QueryChannelRequestSDKType, QueryChannelResponse, QueryChannelResponseSDKType, QueryChannelsRequest, QueryChannelsRequestSDKType, QueryChannelsResponse, QueryChannelsResponseSDKType, QueryConnectionChannelsRequest, QueryConnectionChannelsRequestSDKType, QueryConnectionChannelsResponse, QueryConnectionChannelsResponseSDKType, QueryChannelClientStateRequest, QueryChannelClientStateRequestSDKType, QueryChannelClientStateResponse, QueryChannelClientStateResponseSDKType, QueryChannelConsensusStateRequest, QueryChannelConsensusStateRequestSDKType, QueryChannelConsensusStateResponse, QueryChannelConsensusStateResponseSDKType, QueryPacketCommitmentRequest, QueryPacketCommitmentRequestSDKType, QueryPacketCommitmentResponse, QueryPacketCommitmentResponseSDKType, QueryPacketCommitmentsRequest, QueryPacketCommitmentsRequestSDKType, QueryPacketCommitmentsResponse, QueryPacketCommitmentsResponseSDKType, QueryPacketReceiptRequest, QueryPacketReceiptRequestSDKType, QueryPacketReceiptResponse, QueryPacketReceiptResponseSDKType, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementRequestSDKType, QueryPacketAcknowledgementResponse, QueryPacketAcknowledgementResponseSDKType, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsRequestSDKType, QueryPacketAcknowledgementsResponse, QueryPacketAcknowledgementsResponseSDKType, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsRequestSDKType, QueryUnreceivedPacketsResponse, QueryUnreceivedPacketsResponseSDKType, QueryUnreceivedAcksRequest, QueryUnreceivedAcksRequestSDKType, QueryUnreceivedAcksResponse, QueryUnreceivedAcksResponseSDKType, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveRequestSDKType, QueryNextSequenceReceiveResponse, QueryNextSequenceReceiveResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service */ @@ -230,4 +232,258 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseChannelQuery extends ReactQueryParams { + request: QueryChannelRequest; +} +export interface UseChannelsQuery extends ReactQueryParams { + request?: QueryChannelsRequest; +} +export interface UseConnectionChannelsQuery extends ReactQueryParams { + request: QueryConnectionChannelsRequest; +} +export interface UseChannelClientStateQuery extends ReactQueryParams { + request: QueryChannelClientStateRequest; +} +export interface UseChannelConsensusStateQuery extends ReactQueryParams { + request: QueryChannelConsensusStateRequest; +} +export interface UsePacketCommitmentQuery extends ReactQueryParams { + request: QueryPacketCommitmentRequest; +} +export interface UsePacketCommitmentsQuery extends ReactQueryParams { + request: QueryPacketCommitmentsRequest; +} +export interface UsePacketReceiptQuery extends ReactQueryParams { + request: QueryPacketReceiptRequest; +} +export interface UsePacketAcknowledgementQuery extends ReactQueryParams { + request: QueryPacketAcknowledgementRequest; +} +export interface UsePacketAcknowledgementsQuery extends ReactQueryParams { + request: QueryPacketAcknowledgementsRequest; +} +export interface UseUnreceivedPacketsQuery extends ReactQueryParams { + request: QueryUnreceivedPacketsRequest; +} +export interface UseUnreceivedAcksQuery extends ReactQueryParams { + request: QueryUnreceivedAcksRequest; +} +export interface UseNextSequenceReceiveQuery extends ReactQueryParams { + request: QueryNextSequenceReceiveRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useChannel = ({ + request, + options + }: UseChannelQuery) => { + return useQuery(["channelQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.channel(request); + }, options); + }; + + const useChannels = ({ + request, + options + }: UseChannelsQuery) => { + return useQuery(["channelsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.channels(request); + }, options); + }; + + const useConnectionChannels = ({ + request, + options + }: UseConnectionChannelsQuery) => { + return useQuery(["connectionChannelsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.connectionChannels(request); + }, options); + }; + + const useChannelClientState = ({ + request, + options + }: UseChannelClientStateQuery) => { + return useQuery(["channelClientStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.channelClientState(request); + }, options); + }; + + const useChannelConsensusState = ({ + request, + options + }: UseChannelConsensusStateQuery) => { + return useQuery(["channelConsensusStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.channelConsensusState(request); + }, options); + }; + + const usePacketCommitment = ({ + request, + options + }: UsePacketCommitmentQuery) => { + return useQuery(["packetCommitmentQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.packetCommitment(request); + }, options); + }; + + const usePacketCommitments = ({ + request, + options + }: UsePacketCommitmentsQuery) => { + return useQuery(["packetCommitmentsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.packetCommitments(request); + }, options); + }; + + const usePacketReceipt = ({ + request, + options + }: UsePacketReceiptQuery) => { + return useQuery(["packetReceiptQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.packetReceipt(request); + }, options); + }; + + const usePacketAcknowledgement = ({ + request, + options + }: UsePacketAcknowledgementQuery) => { + return useQuery(["packetAcknowledgementQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.packetAcknowledgement(request); + }, options); + }; + + const usePacketAcknowledgements = ({ + request, + options + }: UsePacketAcknowledgementsQuery) => { + return useQuery(["packetAcknowledgementsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.packetAcknowledgements(request); + }, options); + }; + + const useUnreceivedPackets = ({ + request, + options + }: UseUnreceivedPacketsQuery) => { + return useQuery(["unreceivedPacketsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.unreceivedPackets(request); + }, options); + }; + + const useUnreceivedAcks = ({ + request, + options + }: UseUnreceivedAcksQuery) => { + return useQuery(["unreceivedAcksQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.unreceivedAcks(request); + }, options); + }; + + const useNextSequenceReceive = ({ + request, + options + }: UseNextSequenceReceiveQuery) => { + return useQuery(["nextSequenceReceiveQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.nextSequenceReceive(request); + }, options); + }; + + return { + /** Channel queries an IBC Channel. */ + useChannel, + + /** Channels queries all the IBC channels of a chain. */ + useChannels, + + /** + * ConnectionChannels queries all the channels associated with a connection + * end. + */ + useConnectionChannels, + + /** + * ChannelClientState queries for the client state for the channel associated + * with the provided channel identifiers. + */ + useChannelClientState, + + /** + * ChannelConsensusState queries for the consensus state for the channel + * associated with the provided channel identifiers. + */ + useChannelConsensusState, + + /** PacketCommitment queries a stored packet commitment hash. */ + usePacketCommitment, + + /** + * PacketCommitments returns all the packet commitments hashes associated + * with a channel. + */ + usePacketCommitments, + + /** + * PacketReceipt queries if a given packet sequence has been received on the + * queried chain + */ + usePacketReceipt, + + /** PacketAcknowledgement queries a stored packet acknowledgement hash. */ + usePacketAcknowledgement, + + /** + * PacketAcknowledgements returns all the packet acknowledgements associated + * with a channel. + */ + usePacketAcknowledgements, + + /** + * UnreceivedPackets returns all the unreceived IBC packets associated with a + * channel and sequences. + */ + useUnreceivedPackets, + + /** + * UnreceivedAcks returns all the unreceived IBC acknowledgements associated + * with a channel and sequences. + */ + useUnreceivedAcks, + + /** NextSequenceReceive returns the next receive sequence for a given channel. */ + useNextSequenceReceive + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/ibc/core/client/v1/query.rpc.query.ts b/__fixtures__/output1/ibc/core/client/v1/query.rpc.Query.ts similarity index 57% rename from __fixtures__/output1/ibc/core/client/v1/query.rpc.query.ts rename to __fixtures__/output1/ibc/core/client/v1/query.rpc.Query.ts index 41dd19d580..a5d28cbfc5 100644 --- a/__fixtures__/output1/ibc/core/client/v1/query.rpc.query.ts +++ b/__fixtures__/output1/ibc/core/client/v1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { Any, AnySDKType } from "../../../../google/protobuf/any"; import { Height, HeightSDKType, IdentifiedClientState, IdentifiedClientStateSDKType, ConsensusStateWithHeight, ConsensusStateWithHeightSDKType, Params, ParamsSDKType } from "./client"; import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryClientStateRequest, QueryClientStateRequestSDKType, QueryClientStateResponse, QueryClientStateResponseSDKType, QueryClientStatesRequest, QueryClientStatesRequestSDKType, QueryClientStatesResponse, QueryClientStatesResponseSDKType, QueryConsensusStateRequest, QueryConsensusStateRequestSDKType, QueryConsensusStateResponse, QueryConsensusStateResponseSDKType, QueryConsensusStatesRequest, QueryConsensusStatesRequestSDKType, QueryConsensusStatesResponse, QueryConsensusStatesResponseSDKType, QueryClientStatusRequest, QueryClientStatusRequestSDKType, QueryClientStatusResponse, QueryClientStatusResponseSDKType, QueryClientParamsRequest, QueryClientParamsRequestSDKType, QueryClientParamsResponse, QueryClientParamsResponseSDKType, QueryUpgradedClientStateRequest, QueryUpgradedClientStateRequestSDKType, QueryUpgradedClientStateResponse, QueryUpgradedClientStateResponseSDKType, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateRequestSDKType, QueryUpgradedConsensusStateResponse, QueryUpgradedConsensusStateResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service */ @@ -141,4 +143,160 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseClientStateQuery extends ReactQueryParams { + request: QueryClientStateRequest; +} +export interface UseClientStatesQuery extends ReactQueryParams { + request?: QueryClientStatesRequest; +} +export interface UseConsensusStateQuery extends ReactQueryParams { + request: QueryConsensusStateRequest; +} +export interface UseConsensusStatesQuery extends ReactQueryParams { + request: QueryConsensusStatesRequest; +} +export interface UseClientStatusQuery extends ReactQueryParams { + request: QueryClientStatusRequest; +} +export interface UseClientParamsQuery extends ReactQueryParams { + request?: QueryClientParamsRequest; +} +export interface UseUpgradedClientStateQuery extends ReactQueryParams { + request?: QueryUpgradedClientStateRequest; +} +export interface UseUpgradedConsensusStateQuery extends ReactQueryParams { + request?: QueryUpgradedConsensusStateRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useClientState = ({ + request, + options + }: UseClientStateQuery) => { + return useQuery(["clientStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.clientState(request); + }, options); + }; + + const useClientStates = ({ + request, + options + }: UseClientStatesQuery) => { + return useQuery(["clientStatesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.clientStates(request); + }, options); + }; + + const useConsensusState = ({ + request, + options + }: UseConsensusStateQuery) => { + return useQuery(["consensusStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.consensusState(request); + }, options); + }; + + const useConsensusStates = ({ + request, + options + }: UseConsensusStatesQuery) => { + return useQuery(["consensusStatesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.consensusStates(request); + }, options); + }; + + const useClientStatus = ({ + request, + options + }: UseClientStatusQuery) => { + return useQuery(["clientStatusQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.clientStatus(request); + }, options); + }; + + const useClientParams = ({ + request, + options + }: UseClientParamsQuery) => { + return useQuery(["clientParamsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.clientParams(request); + }, options); + }; + + const useUpgradedClientState = ({ + request, + options + }: UseUpgradedClientStateQuery) => { + return useQuery(["upgradedClientStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.upgradedClientState(request); + }, options); + }; + + const useUpgradedConsensusState = ({ + request, + options + }: UseUpgradedConsensusStateQuery) => { + return useQuery(["upgradedConsensusStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.upgradedConsensusState(request); + }, options); + }; + + return { + /** ClientState queries an IBC light client. */ + useClientState, + + /** ClientStates queries all the IBC light clients of a chain. */ + useClientStates, + + /** + * ConsensusState queries a consensus state associated with a client state at + * a given height. + */ + useConsensusState, + + /** + * ConsensusStates queries all the consensus state associated with a given + * client. + */ + useConsensusStates, + + /** Status queries the status of an IBC client. */ + useClientStatus, + + /** ClientParams queries all parameters of the ibc client. */ + useClientParams, + + /** UpgradedClientState queries an Upgraded IBC light client. */ + useUpgradedClientState, + + /** UpgradedConsensusState queries an Upgraded IBC consensus state. */ + useUpgradedConsensusState + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/ibc/core/connection/v1/query.rpc.query.ts b/__fixtures__/output1/ibc/core/connection/v1/query.rpc.Query.ts similarity index 57% rename from __fixtures__/output1/ibc/core/connection/v1/query.rpc.query.ts rename to __fixtures__/output1/ibc/core/connection/v1/query.rpc.Query.ts index 8918ff2753..f46d187f8b 100644 --- a/__fixtures__/output1/ibc/core/connection/v1/query.rpc.query.ts +++ b/__fixtures__/output1/ibc/core/connection/v1/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { Height, HeightSDKType, IdentifiedClientState, IdentifiedClientStateSDKT import { Any, AnySDKType } from "../../../../google/protobuf/any"; import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryConnectionRequest, QueryConnectionRequestSDKType, QueryConnectionResponse, QueryConnectionResponseSDKType, QueryConnectionsRequest, QueryConnectionsRequestSDKType, QueryConnectionsResponse, QueryConnectionsResponseSDKType, QueryClientConnectionsRequest, QueryClientConnectionsRequestSDKType, QueryClientConnectionsResponse, QueryClientConnectionsResponseSDKType, QueryConnectionClientStateRequest, QueryConnectionClientStateRequestSDKType, QueryConnectionClientStateResponse, QueryConnectionClientStateResponseSDKType, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateRequestSDKType, QueryConnectionConsensusStateResponse, QueryConnectionConsensusStateResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service */ @@ -103,4 +105,115 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseConnectionQuery extends ReactQueryParams { + request: QueryConnectionRequest; +} +export interface UseConnectionsQuery extends ReactQueryParams { + request?: QueryConnectionsRequest; +} +export interface UseClientConnectionsQuery extends ReactQueryParams { + request: QueryClientConnectionsRequest; +} +export interface UseConnectionClientStateQuery extends ReactQueryParams { + request: QueryConnectionClientStateRequest; +} +export interface UseConnectionConsensusStateQuery extends ReactQueryParams { + request: QueryConnectionConsensusStateRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useConnection = ({ + request, + options + }: UseConnectionQuery) => { + return useQuery(["connectionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.connection(request); + }, options); + }; + + const useConnections = ({ + request, + options + }: UseConnectionsQuery) => { + return useQuery(["connectionsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.connections(request); + }, options); + }; + + const useClientConnections = ({ + request, + options + }: UseClientConnectionsQuery) => { + return useQuery(["clientConnectionsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.clientConnections(request); + }, options); + }; + + const useConnectionClientState = ({ + request, + options + }: UseConnectionClientStateQuery) => { + return useQuery(["connectionClientStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.connectionClientState(request); + }, options); + }; + + const useConnectionConsensusState = ({ + request, + options + }: UseConnectionConsensusStateQuery) => { + return useQuery(["connectionConsensusStateQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.connectionConsensusState(request); + }, options); + }; + + return { + /** Connection queries an IBC connection end. */ + useConnection, + + /** Connections queries all the IBC connections of a chain. */ + useConnections, + + /** + * ClientConnections queries the connection paths associated with a client + * state. + */ + useClientConnections, + + /** + * ConnectionClientState queries the client state associated with the + * connection. + */ + useConnectionClientState, + + /** + * ConnectionConsensusState queries the consensus state associated with the + * connection. + */ + useConnectionConsensusState + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/ibc/core/port/v1/query.rpc.query.ts b/__fixtures__/output1/ibc/core/port/v1/query.rpc.Query.ts similarity index 50% rename from __fixtures__/output1/ibc/core/port/v1/query.rpc.query.ts rename to __fixtures__/output1/ibc/core/port/v1/query.rpc.Query.ts index 4415828783..06189ba484 100644 --- a/__fixtures__/output1/ibc/core/port/v1/query.rpc.query.ts +++ b/__fixtures__/output1/ibc/core/port/v1/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { Order, OrderSDKType, Counterparty, CounterpartySDKType } from "../../channel/v1/channel"; import { Rpc } from "../../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryAppVersionRequest, QueryAppVersionRequestSDKType, QueryAppVersionResponse, QueryAppVersionResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -33,4 +35,42 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseAppVersionQuery extends ReactQueryParams { + request: QueryAppVersionRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAppVersion = ({ + request, + options + }: UseAppVersionQuery) => { + return useQuery(["appVersionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.appVersion(request); + }, options); + }; + + return { + /** AppVersion queries an IBC Port and determines the appropriate application version to be used */ + useAppVersion + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/claim/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/claim/v1beta1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/osmosis/claim/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/claim/v1beta1/query.rpc.Query.ts index 22c0d55d43..30e75ef62b 100644 --- a/__fixtures__/output1/osmosis/claim/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/claim/v1beta1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin"; import { Params, ParamsSDKType } from "./params"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryModuleAccountBalanceRequest, QueryModuleAccountBalanceRequestSDKType, QueryModuleAccountBalanceResponse, QueryModuleAccountBalanceResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryClaimRecordRequest, QueryClaimRecordRequestSDKType, QueryClaimRecordResponse, QueryClaimRecordResponseSDKType, QueryClaimableForActionRequest, QueryClaimableForActionRequestSDKType, QueryClaimableForActionResponse, QueryClaimableForActionResponseSDKType, QueryTotalClaimableRequest, QueryTotalClaimableRequestSDKType, QueryTotalClaimableResponse, QueryTotalClaimableResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -82,4 +84,97 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseModuleAccountBalanceQuery extends ReactQueryParams { + request?: QueryModuleAccountBalanceRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseClaimRecordQuery extends ReactQueryParams { + request: QueryClaimRecordRequest; +} +export interface UseClaimableForActionQuery extends ReactQueryParams { + request: QueryClaimableForActionRequest; +} +export interface UseTotalClaimableQuery extends ReactQueryParams { + request: QueryTotalClaimableRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useModuleAccountBalance = ({ + request, + options + }: UseModuleAccountBalanceQuery) => { + return useQuery(["moduleAccountBalanceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleAccountBalance(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useClaimRecord = ({ + request, + options + }: UseClaimRecordQuery) => { + return useQuery(["claimRecordQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.claimRecord(request); + }, options); + }; + + const useClaimableForAction = ({ + request, + options + }: UseClaimableForActionQuery) => { + return useQuery(["claimableForActionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.claimableForAction(request); + }, options); + }; + + const useTotalClaimable = ({ + request, + options + }: UseTotalClaimableQuery) => { + return useQuery(["totalClaimableQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalClaimable(request); + }, options); + }; + + return { + useModuleAccountBalance, + useParams, + useClaimRecord, + useClaimableForAction, + useTotalClaimable + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/epochs/query.rpc.query.ts b/__fixtures__/output1/osmosis/epochs/query.rpc.Query.ts similarity index 52% rename from __fixtures__/output1/osmosis/epochs/query.rpc.query.ts rename to __fixtures__/output1/osmosis/epochs/query.rpc.Query.ts index 0feb8fd6fa..77e5e37d2a 100644 --- a/__fixtures__/output1/osmosis/epochs/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/epochs/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { EpochInfo, EpochInfoSDKType } from "./genesis"; import { Rpc } from "../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryEpochsInfoRequest, QueryEpochsInfoRequestSDKType, QueryEpochsInfoResponse, QueryEpochsInfoResponseSDKType, QueryCurrentEpochRequest, QueryCurrentEpochRequestSDKType, QueryCurrentEpochResponse, QueryCurrentEpochResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -47,4 +49,58 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseEpochInfosQuery extends ReactQueryParams { + request?: QueryEpochsInfoRequest; +} +export interface UseCurrentEpochQuery extends ReactQueryParams { + request: QueryCurrentEpochRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useEpochInfos = ({ + request, + options + }: UseEpochInfosQuery) => { + return useQuery(["epochInfosQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.epochInfos(request); + }, options); + }; + + const useCurrentEpoch = ({ + request, + options + }: UseCurrentEpochQuery) => { + return useQuery(["currentEpochQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.currentEpoch(request); + }, options); + }; + + return { + /** EpochInfos provide running epochInfos */ + useEpochInfos, + + /** CurrentEpoch provide current epoch of specified identifier */ + useCurrentEpoch + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/gamm/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/gamm/v1beta1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/osmosis/gamm/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/gamm/v1beta1/query.rpc.Query.ts index 9852fdaa84..259ed999b1 100644 --- a/__fixtures__/output1/osmosis/gamm/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/gamm/v1beta1/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { Any, AnySDKType } from "../../../google/protobuf/any"; import { Coin, CoinSDKType } from "../../../cosmos/base/v1beta1/coin"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryPoolsRequest, QueryPoolsRequestSDKType, QueryPoolsResponse, QueryPoolsResponseSDKType, QueryNumPoolsRequest, QueryNumPoolsRequestSDKType, QueryNumPoolsResponse, QueryNumPoolsResponseSDKType, QueryTotalLiquidityRequest, QueryTotalLiquidityRequestSDKType, QueryTotalLiquidityResponse, QueryTotalLiquidityResponseSDKType, QueryPoolRequest, QueryPoolRequestSDKType, QueryPoolResponse, QueryPoolResponseSDKType, QueryPoolTypeRequest, QueryPoolTypeRequestSDKType, QueryPoolTypeResponse, QueryPoolTypeResponseSDKType, QueryPoolParamsRequest, QueryPoolParamsRequestSDKType, QueryPoolParamsResponse, QueryPoolParamsResponseSDKType, QueryTotalPoolLiquidityRequest, QueryTotalPoolLiquidityRequestSDKType, QueryTotalPoolLiquidityResponse, QueryTotalPoolLiquidityResponseSDKType, QueryTotalSharesRequest, QueryTotalSharesRequestSDKType, QueryTotalSharesResponse, QueryTotalSharesResponseSDKType, QuerySpotPriceRequest, QuerySpotPriceRequestSDKType, QuerySpotPriceResponse, QuerySpotPriceResponseSDKType, QuerySwapExactAmountInRequest, QuerySwapExactAmountInRequestSDKType, QuerySwapExactAmountInResponse, QuerySwapExactAmountInResponseSDKType, QuerySwapExactAmountOutRequest, QuerySwapExactAmountOutRequestSDKType, QuerySwapExactAmountOutResponse, QuerySwapExactAmountOutResponseSDKType } from "./query"; export interface Query { pools(request?: QueryPoolsRequest): Promise; @@ -170,4 +172,196 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UsePoolsQuery extends ReactQueryParams { + request?: QueryPoolsRequest; +} +export interface UseNumPoolsQuery extends ReactQueryParams { + request?: QueryNumPoolsRequest; +} +export interface UseTotalLiquidityQuery extends ReactQueryParams { + request?: QueryTotalLiquidityRequest; +} +export interface UsePoolQuery extends ReactQueryParams { + request: QueryPoolRequest; +} +export interface UsePoolTypeQuery extends ReactQueryParams { + request: QueryPoolTypeRequest; +} +export interface UsePoolParamsQuery extends ReactQueryParams { + request: QueryPoolParamsRequest; +} +export interface UseTotalPoolLiquidityQuery extends ReactQueryParams { + request: QueryTotalPoolLiquidityRequest; +} +export interface UseTotalSharesQuery extends ReactQueryParams { + request: QueryTotalSharesRequest; +} +export interface UseSpotPriceQuery extends ReactQueryParams { + request: QuerySpotPriceRequest; +} +export interface UseEstimateSwapExactAmountInQuery extends ReactQueryParams { + request: QuerySwapExactAmountInRequest; +} +export interface UseEstimateSwapExactAmountOutQuery extends ReactQueryParams { + request: QuerySwapExactAmountOutRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const usePools = ({ + request, + options + }: UsePoolsQuery) => { + return useQuery(["poolsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.pools(request); + }, options); + }; + + const useNumPools = ({ + request, + options + }: UseNumPoolsQuery) => { + return useQuery(["numPoolsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.numPools(request); + }, options); + }; + + const useTotalLiquidity = ({ + request, + options + }: UseTotalLiquidityQuery) => { + return useQuery(["totalLiquidityQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalLiquidity(request); + }, options); + }; + + const usePool = ({ + request, + options + }: UsePoolQuery) => { + return useQuery(["poolQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.pool(request); + }, options); + }; + + const usePoolType = ({ + request, + options + }: UsePoolTypeQuery) => { + return useQuery(["poolTypeQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.poolType(request); + }, options); + }; + + const usePoolParams = ({ + request, + options + }: UsePoolParamsQuery) => { + return useQuery(["poolParamsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.poolParams(request); + }, options); + }; + + const useTotalPoolLiquidity = ({ + request, + options + }: UseTotalPoolLiquidityQuery) => { + return useQuery(["totalPoolLiquidityQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalPoolLiquidity(request); + }, options); + }; + + const useTotalShares = ({ + request, + options + }: UseTotalSharesQuery) => { + return useQuery(["totalSharesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalShares(request); + }, options); + }; + + const useSpotPrice = ({ + request, + options + }: UseSpotPriceQuery) => { + return useQuery(["spotPriceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.spotPrice(request); + }, options); + }; + + const useEstimateSwapExactAmountIn = ({ + request, + options + }: UseEstimateSwapExactAmountInQuery) => { + return useQuery(["estimateSwapExactAmountInQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.estimateSwapExactAmountIn(request); + }, options); + }; + + const useEstimateSwapExactAmountOut = ({ + request, + options + }: UseEstimateSwapExactAmountOutQuery) => { + return useQuery(["estimateSwapExactAmountOutQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.estimateSwapExactAmountOut(request); + }, options); + }; + + return { + usePools, + useNumPools, + useTotalLiquidity, + + /** Per Pool gRPC Endpoints */ + usePool, + + /** + * PoolType returns the type of the pool. + * Returns "Balancer" as a string literal when the pool is a balancer pool. + * Errors if the pool is failed to be type caseted. + */ + usePoolType, + usePoolParams, + useTotalPoolLiquidity, + useTotalShares, + + /** + * SpotPrice defines a gRPC query handler that returns the spot price given + * a base denomination and a quote denomination. + */ + useSpotPrice, + + /** Estimate the swap. */ + useEstimateSwapExactAmountIn, + useEstimateSwapExactAmountOut + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/incentives/query.rpc.query.ts b/__fixtures__/output1/osmosis/incentives/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/osmosis/incentives/query.rpc.query.ts rename to __fixtures__/output1/osmosis/incentives/query.rpc.Query.ts index 00389313ec..688ebba105 100644 --- a/__fixtures__/output1/osmosis/incentives/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/incentives/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { Gauge, GaugeSDKType } from "./gauge"; import { Duration, DurationSDKType } from "../../google/protobuf/duration"; import { Rpc } from "../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { ModuleToDistributeCoinsRequest, ModuleToDistributeCoinsRequestSDKType, ModuleToDistributeCoinsResponse, ModuleToDistributeCoinsResponseSDKType, ModuleDistributedCoinsRequest, ModuleDistributedCoinsRequestSDKType, ModuleDistributedCoinsResponse, ModuleDistributedCoinsResponseSDKType, GaugeByIDRequest, GaugeByIDRequestSDKType, GaugeByIDResponse, GaugeByIDResponseSDKType, GaugesRequest, GaugesRequestSDKType, GaugesResponse, GaugesResponseSDKType, ActiveGaugesRequest, ActiveGaugesRequestSDKType, ActiveGaugesResponse, ActiveGaugesResponseSDKType, ActiveGaugesPerDenomRequest, ActiveGaugesPerDenomRequestSDKType, ActiveGaugesPerDenomResponse, ActiveGaugesPerDenomResponseSDKType, UpcomingGaugesRequest, UpcomingGaugesRequestSDKType, UpcomingGaugesResponse, UpcomingGaugesResponseSDKType, UpcomingGaugesPerDenomRequest, UpcomingGaugesPerDenomRequestSDKType, UpcomingGaugesPerDenomResponse, UpcomingGaugesPerDenomResponseSDKType, RewardsEstRequest, RewardsEstRequestSDKType, RewardsEstResponse, RewardsEstResponseSDKType, QueryLockableDurationsRequest, QueryLockableDurationsRequestSDKType, QueryLockableDurationsResponse, QueryLockableDurationsResponseSDKType } from "./query"; /** Query defines the gRPC querier service */ @@ -181,4 +183,199 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseModuleToDistributeCoinsQuery extends ReactQueryParams { + request?: ModuleToDistributeCoinsRequest; +} +export interface UseModuleDistributedCoinsQuery extends ReactQueryParams { + request?: ModuleDistributedCoinsRequest; +} +export interface UseGaugeByIDQuery extends ReactQueryParams { + request: GaugeByIDRequest; +} +export interface UseGaugesQuery extends ReactQueryParams { + request?: GaugesRequest; +} +export interface UseActiveGaugesQuery extends ReactQueryParams { + request?: ActiveGaugesRequest; +} +export interface UseActiveGaugesPerDenomQuery extends ReactQueryParams { + request: ActiveGaugesPerDenomRequest; +} +export interface UseUpcomingGaugesQuery extends ReactQueryParams { + request?: UpcomingGaugesRequest; +} +export interface UseUpcomingGaugesPerDenomQuery extends ReactQueryParams { + request: UpcomingGaugesPerDenomRequest; +} +export interface UseRewardsEstQuery extends ReactQueryParams { + request: RewardsEstRequest; +} +export interface UseLockableDurationsQuery extends ReactQueryParams { + request?: QueryLockableDurationsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useModuleToDistributeCoins = ({ + request, + options + }: UseModuleToDistributeCoinsQuery) => { + return useQuery(["moduleToDistributeCoinsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleToDistributeCoins(request); + }, options); + }; + + const useModuleDistributedCoins = ({ + request, + options + }: UseModuleDistributedCoinsQuery) => { + return useQuery(["moduleDistributedCoinsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleDistributedCoins(request); + }, options); + }; + + const useGaugeByID = ({ + request, + options + }: UseGaugeByIDQuery) => { + return useQuery(["gaugeByIDQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.gaugeByID(request); + }, options); + }; + + const useGauges = ({ + request, + options + }: UseGaugesQuery) => { + return useQuery(["gaugesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.gauges(request); + }, options); + }; + + const useActiveGauges = ({ + request, + options + }: UseActiveGaugesQuery) => { + return useQuery(["activeGaugesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.activeGauges(request); + }, options); + }; + + const useActiveGaugesPerDenom = ({ + request, + options + }: UseActiveGaugesPerDenomQuery) => { + return useQuery(["activeGaugesPerDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.activeGaugesPerDenom(request); + }, options); + }; + + const useUpcomingGauges = ({ + request, + options + }: UseUpcomingGaugesQuery) => { + return useQuery(["upcomingGaugesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.upcomingGauges(request); + }, options); + }; + + const useUpcomingGaugesPerDenom = ({ + request, + options + }: UseUpcomingGaugesPerDenomQuery) => { + return useQuery(["upcomingGaugesPerDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.upcomingGaugesPerDenom(request); + }, options); + }; + + const useRewardsEst = ({ + request, + options + }: UseRewardsEstQuery) => { + return useQuery(["rewardsEstQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.rewardsEst(request); + }, options); + }; + + const useLockableDurations = ({ + request, + options + }: UseLockableDurationsQuery) => { + return useQuery(["lockableDurationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.lockableDurations(request); + }, options); + }; + + return { + /** ModuleToDistributeCoins returns coins that are going to be distributed */ + useModuleToDistributeCoins, + + /** + * ModuleDistributedCoins returns coins that are distributed by the module so + * far + */ + useModuleDistributedCoins, + + /** GaugeByID returns gauges by their respective ID */ + useGaugeByID, + + /** Gauges returns both upcoming and active gauges */ + useGauges, + + /** ActiveGauges returns active gauges */ + useActiveGauges, + + /** ActiveGaugesPerDenom returns active gauges by denom */ + useActiveGaugesPerDenom, + + /** Returns scheduled gauges that have not yet occured */ + useUpcomingGauges, + + /** + * UpcomingGaugesPerDenom returns scheduled gauges that have not yet occured + * by denom + */ + useUpcomingGaugesPerDenom, + + /** + * RewardsEst returns an estimate of the rewards from now until a specified + * time in the future The querier either provides an address or a set of locks + * for which they want to find the associated rewards + */ + useRewardsEst, + + /** + * LockableDurations returns lockable durations that are valid to distribute + * incentives for + */ + useLockableDurations + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/lockup/query.rpc.query.ts b/__fixtures__/output1/osmosis/lockup/query.rpc.Query.ts similarity index 57% rename from __fixtures__/output1/osmosis/lockup/query.rpc.query.ts rename to __fixtures__/output1/osmosis/lockup/query.rpc.Query.ts index aa67b61555..93e2e7ae99 100644 --- a/__fixtures__/output1/osmosis/lockup/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/lockup/query.rpc.Query.ts @@ -4,7 +4,9 @@ import { Coin, CoinSDKType } from "../../cosmos/base/v1beta1/coin"; import { PeriodLock, PeriodLockSDKType, SyntheticLock, SyntheticLockSDKType } from "./lock"; import { Rpc } from "../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { ModuleBalanceRequest, ModuleBalanceRequestSDKType, ModuleBalanceResponse, ModuleBalanceResponseSDKType, ModuleLockedAmountRequest, ModuleLockedAmountRequestSDKType, ModuleLockedAmountResponse, ModuleLockedAmountResponseSDKType, AccountUnlockableCoinsRequest, AccountUnlockableCoinsRequestSDKType, AccountUnlockableCoinsResponse, AccountUnlockableCoinsResponseSDKType, AccountUnlockingCoinsRequest, AccountUnlockingCoinsRequestSDKType, AccountUnlockingCoinsResponse, AccountUnlockingCoinsResponseSDKType, AccountLockedCoinsRequest, AccountLockedCoinsRequestSDKType, AccountLockedCoinsResponse, AccountLockedCoinsResponseSDKType, AccountLockedPastTimeRequest, AccountLockedPastTimeRequestSDKType, AccountLockedPastTimeResponse, AccountLockedPastTimeResponseSDKType, AccountLockedPastTimeNotUnlockingOnlyRequest, AccountLockedPastTimeNotUnlockingOnlyRequestSDKType, AccountLockedPastTimeNotUnlockingOnlyResponse, AccountLockedPastTimeNotUnlockingOnlyResponseSDKType, AccountUnlockedBeforeTimeRequest, AccountUnlockedBeforeTimeRequestSDKType, AccountUnlockedBeforeTimeResponse, AccountUnlockedBeforeTimeResponseSDKType, AccountLockedPastTimeDenomRequest, AccountLockedPastTimeDenomRequestSDKType, AccountLockedPastTimeDenomResponse, AccountLockedPastTimeDenomResponseSDKType, LockedDenomRequest, LockedDenomRequestSDKType, LockedDenomResponse, LockedDenomResponseSDKType, LockedRequest, LockedRequestSDKType, LockedResponse, LockedResponseSDKType, SyntheticLockupsByLockupIDRequest, SyntheticLockupsByLockupIDRequestSDKType, SyntheticLockupsByLockupIDResponse, SyntheticLockupsByLockupIDResponseSDKType, AccountLockedLongerDurationRequest, AccountLockedLongerDurationRequestSDKType, AccountLockedLongerDurationResponse, AccountLockedLongerDurationResponseSDKType, AccountLockedDurationRequest, AccountLockedDurationRequestSDKType, AccountLockedDurationResponse, AccountLockedDurationResponseSDKType, AccountLockedLongerDurationNotUnlockingOnlyRequest, AccountLockedLongerDurationNotUnlockingOnlyRequestSDKType, AccountLockedLongerDurationNotUnlockingOnlyResponse, AccountLockedLongerDurationNotUnlockingOnlyResponseSDKType, AccountLockedLongerDurationDenomRequest, AccountLockedLongerDurationDenomRequestSDKType, AccountLockedLongerDurationDenomResponse, AccountLockedLongerDurationDenomResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -252,4 +254,288 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseModuleBalanceQuery extends ReactQueryParams { + request?: ModuleBalanceRequest; +} +export interface UseModuleLockedAmountQuery extends ReactQueryParams { + request?: ModuleLockedAmountRequest; +} +export interface UseAccountUnlockableCoinsQuery extends ReactQueryParams { + request: AccountUnlockableCoinsRequest; +} +export interface UseAccountUnlockingCoinsQuery extends ReactQueryParams { + request: AccountUnlockingCoinsRequest; +} +export interface UseAccountLockedCoinsQuery extends ReactQueryParams { + request: AccountLockedCoinsRequest; +} +export interface UseAccountLockedPastTimeQuery extends ReactQueryParams { + request: AccountLockedPastTimeRequest; +} +export interface UseAccountLockedPastTimeNotUnlockingOnlyQuery extends ReactQueryParams { + request: AccountLockedPastTimeNotUnlockingOnlyRequest; +} +export interface UseAccountUnlockedBeforeTimeQuery extends ReactQueryParams { + request: AccountUnlockedBeforeTimeRequest; +} +export interface UseAccountLockedPastTimeDenomQuery extends ReactQueryParams { + request: AccountLockedPastTimeDenomRequest; +} +export interface UseLockedDenomQuery extends ReactQueryParams { + request: LockedDenomRequest; +} +export interface UseLockedByIDQuery extends ReactQueryParams { + request: LockedRequest; +} +export interface UseSyntheticLockupsByLockupIDQuery extends ReactQueryParams { + request: SyntheticLockupsByLockupIDRequest; +} +export interface UseAccountLockedLongerDurationQuery extends ReactQueryParams { + request: AccountLockedLongerDurationRequest; +} +export interface UseAccountLockedDurationQuery extends ReactQueryParams { + request: AccountLockedDurationRequest; +} +export interface UseAccountLockedLongerDurationNotUnlockingOnlyQuery extends ReactQueryParams { + request: AccountLockedLongerDurationNotUnlockingOnlyRequest; +} +export interface UseAccountLockedLongerDurationDenomQuery extends ReactQueryParams { + request: AccountLockedLongerDurationDenomRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useModuleBalance = ({ + request, + options + }: UseModuleBalanceQuery) => { + return useQuery(["moduleBalanceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleBalance(request); + }, options); + }; + + const useModuleLockedAmount = ({ + request, + options + }: UseModuleLockedAmountQuery) => { + return useQuery(["moduleLockedAmountQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleLockedAmount(request); + }, options); + }; + + const useAccountUnlockableCoins = ({ + request, + options + }: UseAccountUnlockableCoinsQuery) => { + return useQuery(["accountUnlockableCoinsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountUnlockableCoins(request); + }, options); + }; + + const useAccountUnlockingCoins = ({ + request, + options + }: UseAccountUnlockingCoinsQuery) => { + return useQuery(["accountUnlockingCoinsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountUnlockingCoins(request); + }, options); + }; + + const useAccountLockedCoins = ({ + request, + options + }: UseAccountLockedCoinsQuery) => { + return useQuery(["accountLockedCoinsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedCoins(request); + }, options); + }; + + const useAccountLockedPastTime = ({ + request, + options + }: UseAccountLockedPastTimeQuery) => { + return useQuery(["accountLockedPastTimeQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedPastTime(request); + }, options); + }; + + const useAccountLockedPastTimeNotUnlockingOnly = ({ + request, + options + }: UseAccountLockedPastTimeNotUnlockingOnlyQuery) => { + return useQuery(["accountLockedPastTimeNotUnlockingOnlyQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedPastTimeNotUnlockingOnly(request); + }, options); + }; + + const useAccountUnlockedBeforeTime = ({ + request, + options + }: UseAccountUnlockedBeforeTimeQuery) => { + return useQuery(["accountUnlockedBeforeTimeQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountUnlockedBeforeTime(request); + }, options); + }; + + const useAccountLockedPastTimeDenom = ({ + request, + options + }: UseAccountLockedPastTimeDenomQuery) => { + return useQuery(["accountLockedPastTimeDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedPastTimeDenom(request); + }, options); + }; + + const useLockedDenom = ({ + request, + options + }: UseLockedDenomQuery) => { + return useQuery(["lockedDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.lockedDenom(request); + }, options); + }; + + const useLockedByID = ({ + request, + options + }: UseLockedByIDQuery) => { + return useQuery(["lockedByIDQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.lockedByID(request); + }, options); + }; + + const useSyntheticLockupsByLockupID = ({ + request, + options + }: UseSyntheticLockupsByLockupIDQuery) => { + return useQuery(["syntheticLockupsByLockupIDQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.syntheticLockupsByLockupID(request); + }, options); + }; + + const useAccountLockedLongerDuration = ({ + request, + options + }: UseAccountLockedLongerDurationQuery) => { + return useQuery(["accountLockedLongerDurationQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedLongerDuration(request); + }, options); + }; + + const useAccountLockedDuration = ({ + request, + options + }: UseAccountLockedDurationQuery) => { + return useQuery(["accountLockedDurationQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedDuration(request); + }, options); + }; + + const useAccountLockedLongerDurationNotUnlockingOnly = ({ + request, + options + }: UseAccountLockedLongerDurationNotUnlockingOnlyQuery) => { + return useQuery(["accountLockedLongerDurationNotUnlockingOnlyQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedLongerDurationNotUnlockingOnly(request); + }, options); + }; + + const useAccountLockedLongerDurationDenom = ({ + request, + options + }: UseAccountLockedLongerDurationDenomQuery) => { + return useQuery(["accountLockedLongerDurationDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accountLockedLongerDurationDenom(request); + }, options); + }; + + return { + /** Return full balance of the module */ + useModuleBalance, + + /** Return locked balance of the module */ + useModuleLockedAmount, + + /** Returns unlockable coins which are not withdrawn yet */ + useAccountUnlockableCoins, + + /** Returns unlocking coins */ + useAccountUnlockingCoins, + + /** Return a locked coins that can't be withdrawn */ + useAccountLockedCoins, + + /** Returns locked records of an account with unlock time beyond timestamp */ + useAccountLockedPastTime, + + /** + * Returns locked records of an account with unlock time beyond timestamp + * excluding tokens started unlocking + */ + useAccountLockedPastTimeNotUnlockingOnly, + + /** Returns unlocked records with unlock time before timestamp */ + useAccountUnlockedBeforeTime, + + /** Returns lock records by address, timestamp, denom */ + useAccountLockedPastTimeDenom, + + /** Returns total locked per denom with longer past given time */ + useLockedDenom, + + /** Returns lock record by id */ + useLockedByID, + + /** Returns synthetic lockups by native lockup id */ + useSyntheticLockupsByLockupID, + + /** Returns account locked records with longer duration */ + useAccountLockedLongerDuration, + + /** Returns account locked records with a specific duration */ + useAccountLockedDuration, + + /** + * Returns account locked records with longer duration excluding tokens + * started unlocking + */ + useAccountLockedLongerDurationNotUnlockingOnly, + + /** Returns account's locked records for a denom with longer duration */ + useAccountLockedLongerDurationDenom + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/mint/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/mint/v1beta1/query.rpc.Query.ts similarity index 52% rename from __fixtures__/output1/osmosis/mint/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/mint/v1beta1/query.rpc.Query.ts index 6c5665b41a..cd7b619818 100644 --- a/__fixtures__/output1/osmosis/mint/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/mint/v1beta1/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { Params, ParamsSDKType } from "./mint"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryEpochProvisionsRequest, QueryEpochProvisionsRequestSDKType, QueryEpochProvisionsResponse, QueryEpochProvisionsResponseSDKType } from "./query"; /** Query provides defines the gRPC querier service. */ @@ -47,4 +49,58 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseEpochProvisionsQuery extends ReactQueryParams { + request?: QueryEpochProvisionsRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useEpochProvisions = ({ + request, + options + }: UseEpochProvisionsQuery) => { + return useQuery(["epochProvisionsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.epochProvisions(request); + }, options); + }; + + return { + /** Params returns the total set of minting parameters. */ + useParams, + + /** EpochProvisions returns the current minting epoch provisions value. */ + useEpochProvisions + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/pool-incentives/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/pool-incentives/v1beta1/query.rpc.Query.ts similarity index 56% rename from __fixtures__/output1/osmosis/pool-incentives/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/pool-incentives/v1beta1/query.rpc.Query.ts index 6a9688c93c..6463a00831 100644 --- a/__fixtures__/output1/osmosis/pool-incentives/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/pool-incentives/v1beta1/query.rpc.Query.ts @@ -3,7 +3,9 @@ import { DistrInfo, DistrInfoSDKType, Params, ParamsSDKType } from "./incentives import { Gauge, GaugeSDKType } from "../../incentives/gauge"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryGaugeIdsRequest, QueryGaugeIdsRequestSDKType, QueryGaugeIdsResponse, QueryGaugeIdsResponseSDKType, QueryDistrInfoRequest, QueryDistrInfoRequestSDKType, QueryDistrInfoResponse, QueryDistrInfoResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryLockableDurationsRequest, QueryLockableDurationsRequestSDKType, QueryLockableDurationsResponse, QueryLockableDurationsResponseSDKType, QueryIncentivizedPoolsRequest, QueryIncentivizedPoolsRequestSDKType, QueryIncentivizedPoolsResponse, QueryIncentivizedPoolsResponseSDKType, QueryExternalIncentiveGaugesRequest, QueryExternalIncentiveGaugesRequestSDKType, QueryExternalIncentiveGaugesResponse, QueryExternalIncentiveGaugesResponseSDKType } from "./query"; export interface Query { /** GaugeIds takes the pool id and returns the matching gauge ids and durations */ @@ -103,4 +105,122 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseGaugeIdsQuery extends ReactQueryParams { + request: QueryGaugeIdsRequest; +} +export interface UseDistrInfoQuery extends ReactQueryParams { + request?: QueryDistrInfoRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseLockableDurationsQuery extends ReactQueryParams { + request?: QueryLockableDurationsRequest; +} +export interface UseIncentivizedPoolsQuery extends ReactQueryParams { + request?: QueryIncentivizedPoolsRequest; +} +export interface UseExternalIncentiveGaugesQuery extends ReactQueryParams { + request?: QueryExternalIncentiveGaugesRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useGaugeIds = ({ + request, + options + }: UseGaugeIdsQuery) => { + return useQuery(["gaugeIdsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.gaugeIds(request); + }, options); + }; + + const useDistrInfo = ({ + request, + options + }: UseDistrInfoQuery) => { + return useQuery(["distrInfoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.distrInfo(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useLockableDurations = ({ + request, + options + }: UseLockableDurationsQuery) => { + return useQuery(["lockableDurationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.lockableDurations(request); + }, options); + }; + + const useIncentivizedPools = ({ + request, + options + }: UseIncentivizedPoolsQuery) => { + return useQuery(["incentivizedPoolsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.incentivizedPools(request); + }, options); + }; + + const useExternalIncentiveGauges = ({ + request, + options + }: UseExternalIncentiveGaugesQuery) => { + return useQuery(["externalIncentiveGaugesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.externalIncentiveGauges(request); + }, options); + }; + + return { + /** GaugeIds takes the pool id and returns the matching gauge ids and durations */ + useGaugeIds, + + /** DistrInfo returns the pool's matching gauge ids and weights. */ + useDistrInfo, + + /** Params returns pool incentives params. */ + useParams, + + /** LockableDurations returns lock durations for pools. */ + useLockableDurations, + + /** IncentivizedPools returns currently incentivized pools */ + useIncentivizedPools, + + /** ExternalIncentiveGauges returns external incentive gauges. */ + useExternalIncentiveGauges + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/streamswap/v1/query.rpc.query.ts b/__fixtures__/output1/osmosis/streamswap/v1/query.rpc.Query.ts similarity index 53% rename from __fixtures__/output1/osmosis/streamswap/v1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/streamswap/v1/query.rpc.Query.ts index 52e4f77260..230a434dd4 100644 --- a/__fixtures__/output1/osmosis/streamswap/v1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/streamswap/v1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr import { Sale, SaleSDKType, UserPosition, UserPositionSDKType } from "./state"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QuerySales, QuerySalesSDKType, QuerySalesResponse, QuerySalesResponseSDKType, QuerySale, QuerySaleSDKType, QuerySaleResponse, QuerySaleResponseSDKType, QueryUserPosition, QueryUserPositionSDKType, QueryUserPositionResponse, QueryUserPositionResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -62,4 +64,72 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseSalesQuery extends ReactQueryParams { + request?: QuerySales; +} +export interface UseSaleQuery extends ReactQueryParams { + request: QuerySale; +} +export interface UseUserPositionQuery extends ReactQueryParams { + request: QueryUserPosition; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useSales = ({ + request, + options + }: UseSalesQuery) => { + return useQuery(["salesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.sales(request); + }, options); + }; + + const useSale = ({ + request, + options + }: UseSaleQuery) => { + return useQuery(["saleQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.sale(request); + }, options); + }; + + const useUserPosition = ({ + request, + options + }: UseUserPositionQuery) => { + return useQuery(["userPositionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.userPosition(request); + }, options); + }; + + return { + /** Returns list of Sales ordered by the creation time */ + useSales, + + /** Returns the specific Sale object */ + useSale, + useUserPosition + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/superfluid/query.rpc.query.ts b/__fixtures__/output1/osmosis/superfluid/query.rpc.Query.ts similarity index 58% rename from __fixtures__/output1/osmosis/superfluid/query.rpc.query.ts rename to __fixtures__/output1/osmosis/superfluid/query.rpc.Query.ts index f2a33daf23..78a2d78bab 100644 --- a/__fixtures__/output1/osmosis/superfluid/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/superfluid/query.rpc.Query.ts @@ -6,7 +6,9 @@ import { SyntheticLock, SyntheticLockSDKType } from "../lockup/lock"; import { DelegationResponse, DelegationResponseSDKType } from "../../cosmos/staking/v1beta1/staking"; import { Rpc } from "../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, AssetTypeRequest, AssetTypeRequestSDKType, AssetTypeResponse, AssetTypeResponseSDKType, AllAssetsRequest, AllAssetsRequestSDKType, AllAssetsResponse, AllAssetsResponseSDKType, AssetMultiplierRequest, AssetMultiplierRequestSDKType, AssetMultiplierResponse, AssetMultiplierResponseSDKType, AllIntermediaryAccountsRequest, AllIntermediaryAccountsRequestSDKType, AllIntermediaryAccountsResponse, AllIntermediaryAccountsResponseSDKType, ConnectedIntermediaryAccountRequest, ConnectedIntermediaryAccountRequestSDKType, ConnectedIntermediaryAccountResponse, ConnectedIntermediaryAccountResponseSDKType, TotalSuperfluidDelegationsRequest, TotalSuperfluidDelegationsRequestSDKType, TotalSuperfluidDelegationsResponse, TotalSuperfluidDelegationsResponseSDKType, SuperfluidDelegationAmountRequest, SuperfluidDelegationAmountRequestSDKType, SuperfluidDelegationAmountResponse, SuperfluidDelegationAmountResponseSDKType, SuperfluidDelegationsByDelegatorRequest, SuperfluidDelegationsByDelegatorRequestSDKType, SuperfluidDelegationsByDelegatorResponse, SuperfluidDelegationsByDelegatorResponseSDKType, SuperfluidUndelegationsByDelegatorRequest, SuperfluidUndelegationsByDelegatorRequestSDKType, SuperfluidUndelegationsByDelegatorResponse, SuperfluidUndelegationsByDelegatorResponseSDKType, SuperfluidDelegationsByValidatorDenomRequest, SuperfluidDelegationsByValidatorDenomRequestSDKType, SuperfluidDelegationsByValidatorDenomResponse, SuperfluidDelegationsByValidatorDenomResponseSDKType, EstimateSuperfluidDelegatedAmountByValidatorDenomRequest, EstimateSuperfluidDelegatedAmountByValidatorDenomRequestSDKType, EstimateSuperfluidDelegatedAmountByValidatorDenomResponse, EstimateSuperfluidDelegatedAmountByValidatorDenomResponseSDKType, QueryTotalDelegationByDelegatorRequest, QueryTotalDelegationByDelegatorRequestSDKType, QueryTotalDelegationByDelegatorResponse, QueryTotalDelegationByDelegatorResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -224,4 +226,250 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseAssetTypeQuery extends ReactQueryParams { + request: AssetTypeRequest; +} +export interface UseAllAssetsQuery extends ReactQueryParams { + request?: AllAssetsRequest; +} +export interface UseAssetMultiplierQuery extends ReactQueryParams { + request: AssetMultiplierRequest; +} +export interface UseAllIntermediaryAccountsQuery extends ReactQueryParams { + request?: AllIntermediaryAccountsRequest; +} +export interface UseConnectedIntermediaryAccountQuery extends ReactQueryParams { + request: ConnectedIntermediaryAccountRequest; +} +export interface UseTotalSuperfluidDelegationsQuery extends ReactQueryParams { + request?: TotalSuperfluidDelegationsRequest; +} +export interface UseSuperfluidDelegationAmountQuery extends ReactQueryParams { + request: SuperfluidDelegationAmountRequest; +} +export interface UseSuperfluidDelegationsByDelegatorQuery extends ReactQueryParams { + request: SuperfluidDelegationsByDelegatorRequest; +} +export interface UseSuperfluidUndelegationsByDelegatorQuery extends ReactQueryParams { + request: SuperfluidUndelegationsByDelegatorRequest; +} +export interface UseSuperfluidDelegationsByValidatorDenomQuery extends ReactQueryParams { + request: SuperfluidDelegationsByValidatorDenomRequest; +} +export interface UseEstimateSuperfluidDelegatedAmountByValidatorDenomQuery extends ReactQueryParams { + request: EstimateSuperfluidDelegatedAmountByValidatorDenomRequest; +} +export interface UseTotalDelegationByDelegatorQuery extends ReactQueryParams { + request: QueryTotalDelegationByDelegatorRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useAssetType = ({ + request, + options + }: UseAssetTypeQuery) => { + return useQuery(["assetTypeQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.assetType(request); + }, options); + }; + + const useAllAssets = ({ + request, + options + }: UseAllAssetsQuery) => { + return useQuery(["allAssetsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allAssets(request); + }, options); + }; + + const useAssetMultiplier = ({ + request, + options + }: UseAssetMultiplierQuery) => { + return useQuery(["assetMultiplierQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.assetMultiplier(request); + }, options); + }; + + const useAllIntermediaryAccounts = ({ + request, + options + }: UseAllIntermediaryAccountsQuery) => { + return useQuery(["allIntermediaryAccountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.allIntermediaryAccounts(request); + }, options); + }; + + const useConnectedIntermediaryAccount = ({ + request, + options + }: UseConnectedIntermediaryAccountQuery) => { + return useQuery(["connectedIntermediaryAccountQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.connectedIntermediaryAccount(request); + }, options); + }; + + const useTotalSuperfluidDelegations = ({ + request, + options + }: UseTotalSuperfluidDelegationsQuery) => { + return useQuery(["totalSuperfluidDelegationsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalSuperfluidDelegations(request); + }, options); + }; + + const useSuperfluidDelegationAmount = ({ + request, + options + }: UseSuperfluidDelegationAmountQuery) => { + return useQuery(["superfluidDelegationAmountQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.superfluidDelegationAmount(request); + }, options); + }; + + const useSuperfluidDelegationsByDelegator = ({ + request, + options + }: UseSuperfluidDelegationsByDelegatorQuery) => { + return useQuery(["superfluidDelegationsByDelegatorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.superfluidDelegationsByDelegator(request); + }, options); + }; + + const useSuperfluidUndelegationsByDelegator = ({ + request, + options + }: UseSuperfluidUndelegationsByDelegatorQuery) => { + return useQuery(["superfluidUndelegationsByDelegatorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.superfluidUndelegationsByDelegator(request); + }, options); + }; + + const useSuperfluidDelegationsByValidatorDenom = ({ + request, + options + }: UseSuperfluidDelegationsByValidatorDenomQuery) => { + return useQuery(["superfluidDelegationsByValidatorDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.superfluidDelegationsByValidatorDenom(request); + }, options); + }; + + const useEstimateSuperfluidDelegatedAmountByValidatorDenom = ({ + request, + options + }: UseEstimateSuperfluidDelegatedAmountByValidatorDenomQuery) => { + return useQuery(["estimateSuperfluidDelegatedAmountByValidatorDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.estimateSuperfluidDelegatedAmountByValidatorDenom(request); + }, options); + }; + + const useTotalDelegationByDelegator = ({ + request, + options + }: UseTotalDelegationByDelegatorQuery) => { + return useQuery(["totalDelegationByDelegatorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.totalDelegationByDelegator(request); + }, options); + }; + + return { + /** Params returns the total set of superfluid parameters. */ + useParams, + + /** + * Returns superfluid asset type, whether if it's a native asset or an lp + * share. + */ + useAssetType, + + /** Returns all registered superfluid assets. */ + useAllAssets, + + /** Returns the osmo equivalent multiplier used in the most recent epoch. */ + useAssetMultiplier, + + /** Returns all superfluid intermediary accounts. */ + useAllIntermediaryAccounts, + + /** Returns intermediary account connected to a superfluid staked lock by id */ + useConnectedIntermediaryAccount, + + /** + * Returns the total amount of osmo superfluidly staked. + * Response is denominated in uosmo. + */ + useTotalSuperfluidDelegations, + + /** + * Returns the coins superfluid delegated for the delegator, validator, denom + * triplet + */ + useSuperfluidDelegationAmount, + + /** Returns all the delegated superfluid poistions for a specific delegator. */ + useSuperfluidDelegationsByDelegator, + + /** Returns all the undelegating superfluid poistions for a specific delegator. */ + useSuperfluidUndelegationsByDelegator, + + /** + * Returns all the superfluid positions of a specific denom delegated to one + * validator + */ + useSuperfluidDelegationsByValidatorDenom, + + /** + * Returns the amount of a specific denom delegated to a specific validator + * This is labeled an estimate, because the way it calculates the amount can + * lead rounding errors from the true delegated amount + */ + useEstimateSuperfluidDelegatedAmountByValidatorDenom, + + /** Returns the specified delegations for a specific delegator */ + useTotalDelegationByDelegator + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/tokenfactory/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/tokenfactory/v1beta1/query.rpc.Query.ts similarity index 54% rename from __fixtures__/output1/osmosis/tokenfactory/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/tokenfactory/v1beta1/query.rpc.Query.ts index 31803eec37..9b43df083c 100644 --- a/__fixtures__/output1/osmosis/tokenfactory/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/tokenfactory/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { Params, ParamsSDKType } from "./params"; import { DenomAuthorityMetadata, DenomAuthorityMetadataSDKType } from "./authorityMetadata"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataRequestSDKType, QueryDenomAuthorityMetadataResponse, QueryDenomAuthorityMetadataResponseSDKType, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorRequestSDKType, QueryDenomsFromCreatorResponse, QueryDenomsFromCreatorResponseSDKType } from "./query"; /** Query defines the gRPC querier service. */ @@ -71,4 +73,83 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseDenomAuthorityMetadataQuery extends ReactQueryParams { + request: QueryDenomAuthorityMetadataRequest; +} +export interface UseDenomsFromCreatorQuery extends ReactQueryParams { + request: QueryDenomsFromCreatorRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useDenomAuthorityMetadata = ({ + request, + options + }: UseDenomAuthorityMetadataQuery) => { + return useQuery(["denomAuthorityMetadataQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomAuthorityMetadata(request); + }, options); + }; + + const useDenomsFromCreator = ({ + request, + options + }: UseDenomsFromCreatorQuery) => { + return useQuery(["denomsFromCreatorQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomsFromCreator(request); + }, options); + }; + + return { + /** + * Params defines a gRPC query method that returns the tokenfactory module's + * parameters. + */ + useParams, + + /** + * DenomAuthorityMetadata defines a gRPC query method for fetching + * DenomAuthorityMetadata for a particular denom. + */ + useDenomAuthorityMetadata, + + /** + * DenomsFromCreator defines a gRPC query method for fetching all + * denominations created by a specific admin/creator. + */ + useDenomsFromCreator + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/twap/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/twap/v1beta1/query.rpc.Query.ts similarity index 53% rename from __fixtures__/output1/osmosis/twap/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/twap/v1beta1/query.rpc.Query.ts index f1b4643191..d39dc27906 100644 --- a/__fixtures__/output1/osmosis/twap/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/twap/v1beta1/query.rpc.Query.ts @@ -2,7 +2,9 @@ import { Timestamp, TimestampSDKType } from "../../../google/protobuf/timestamp" import { Params, ParamsSDKType } from "./genesis"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { ParamsRequest, ParamsRequestSDKType, ParamsResponse, ParamsResponseSDKType, ArithmeticTwapRequest, ArithmeticTwapRequestSDKType, ArithmeticTwapResponse, ArithmeticTwapResponseSDKType, ArithmeticTwapToNowRequest, ArithmeticTwapToNowRequestSDKType, ArithmeticTwapToNowResponse, ArithmeticTwapToNowResponseSDKType } from "./query"; export interface Query { params(request?: ParamsRequest): Promise; @@ -55,4 +57,69 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseParamsQuery extends ReactQueryParams { + request?: ParamsRequest; +} +export interface UseArithmeticTwapQuery extends ReactQueryParams { + request: ArithmeticTwapRequest; +} +export interface UseArithmeticTwapToNowQuery extends ReactQueryParams { + request: ArithmeticTwapToNowRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useArithmeticTwap = ({ + request, + options + }: UseArithmeticTwapQuery) => { + return useQuery(["arithmeticTwapQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.arithmeticTwap(request); + }, options); + }; + + const useArithmeticTwapToNow = ({ + request, + options + }: UseArithmeticTwapToNowQuery) => { + return useQuery(["arithmeticTwapToNowQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.arithmeticTwapToNow(request); + }, options); + }; + + return { + useParams, + useArithmeticTwap, + useArithmeticTwapToNow + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/osmosis/txfees/v1beta1/query.rpc.query.ts b/__fixtures__/output1/osmosis/txfees/v1beta1/query.rpc.Query.ts similarity index 53% rename from __fixtures__/output1/osmosis/txfees/v1beta1/query.rpc.query.ts rename to __fixtures__/output1/osmosis/txfees/v1beta1/query.rpc.Query.ts index 10afc4d03a..3107a55f7d 100644 --- a/__fixtures__/output1/osmosis/txfees/v1beta1/query.rpc.query.ts +++ b/__fixtures__/output1/osmosis/txfees/v1beta1/query.rpc.Query.ts @@ -1,7 +1,9 @@ import { FeeToken, FeeTokenSDKType } from "./feetoken"; import { Rpc } from "../../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { QueryFeeTokensRequest, QueryFeeTokensRequestSDKType, QueryFeeTokensResponse, QueryFeeTokensResponseSDKType, QueryDenomSpotPriceRequest, QueryDenomSpotPriceRequestSDKType, QueryDenomSpotPriceResponse, QueryDenomSpotPriceResponseSDKType, QueryDenomPoolIdRequest, QueryDenomPoolIdRequestSDKType, QueryDenomPoolIdResponse, QueryDenomPoolIdResponseSDKType, QueryBaseDenomRequest, QueryBaseDenomRequestSDKType, QueryBaseDenomResponse, QueryBaseDenomResponseSDKType } from "./query"; export interface Query { /** @@ -77,4 +79,94 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseFeeTokensQuery extends ReactQueryParams { + request?: QueryFeeTokensRequest; +} +export interface UseDenomSpotPriceQuery extends ReactQueryParams { + request: QueryDenomSpotPriceRequest; +} +export interface UseDenomPoolIdQuery extends ReactQueryParams { + request: QueryDenomPoolIdRequest; +} +export interface UseBaseDenomQuery extends ReactQueryParams { + request?: QueryBaseDenomRequest; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useFeeTokens = ({ + request, + options + }: UseFeeTokensQuery) => { + return useQuery(["feeTokensQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.feeTokens(request); + }, options); + }; + + const useDenomSpotPrice = ({ + request, + options + }: UseDenomSpotPriceQuery) => { + return useQuery(["denomSpotPriceQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomSpotPrice(request); + }, options); + }; + + const useDenomPoolId = ({ + request, + options + }: UseDenomPoolIdQuery) => { + return useQuery(["denomPoolIdQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.denomPoolId(request); + }, options); + }; + + const useBaseDenom = ({ + request, + options + }: UseBaseDenomQuery) => { + return useQuery(["baseDenomQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.baseDenom(request); + }, options); + }; + + return { + /** + * FeeTokens returns a list of all the whitelisted fee tokens and their + * corresponding pools. It does not include the BaseDenom, which has its own + * query endpoint + */ + useFeeTokens, + + /** DenomSpotPrice returns all spot prices by each registered token denom. */ + useDenomSpotPrice, + + /** Returns the poolID for a specified denom input. */ + useDenomPoolId, + + /** Returns a list of all base denom tokens and their corresponding pools. */ + useBaseDenom + }; }; \ No newline at end of file diff --git a/__fixtures__/output1/react-query.ts b/__fixtures__/output1/react-query.ts new file mode 100644 index 0000000000..901246938c --- /dev/null +++ b/__fixtures__/output1/react-query.ts @@ -0,0 +1,69 @@ +/** +* This file and any referenced files were automatically generated by @osmonauts/telescope@latest +* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain +* and run the transpile command or yarn proto command to regenerate this bundle. +*/ + +import { getRpcClient } from './extern' +import { + useQuery, + UseQueryOptions, +} from '@tanstack/react-query'; + +import { HttpEndpoint, ProtobufRpcClient } from '@cosmjs/stargate'; +import { Tendermint34Client } from '@cosmjs/tendermint-rpc'; + +export interface ReactQueryParams { + options?: UseQueryOptions; +} + +export interface UseRpcClientQuery extends ReactQueryParams { + rpcEndpoint: string | HttpEndpoint; +} + +export interface UseRpcEndpointQuery extends ReactQueryParams { + getter: () => Promise; +} + +export const useRpcEndpoint = ({ + getter, + options, +}: UseRpcEndpointQuery) => { + return useQuery(['rpcEndpoint', getter], async () => { + return await getter(); + }, options); +}; + +export const useRpcClient = ({ + rpcEndpoint, + options, +}: UseRpcClientQuery) => { + return useQuery(['rpcClient', rpcEndpoint], async () => { + return await getRpcClient(rpcEndpoint); + }, options); +}; + +interface UseTendermintClient extends ReactQueryParams { + rpcEndpoint: string | HttpEndpoint; +} + +/** + * Hook that uses react-query to cache a connected tendermint client. + */ +export const useTendermintClient = ({ + rpcEndpoint, + options, +}: UseTendermintClient) => { + const { data: client } = useQuery( + ['client', 'tendermint', rpcEndpoint], + () => Tendermint34Client.connect(rpcEndpoint), + { + // allow overriding + onError: (e) => { + throw new Error(`Failed to connect to ${rpcEndpoint}` + '\n' + e) + }, + ...options, + } + ) + return { client } +}; diff --git a/__fixtures__/output1/tendermint/abci/types.rpc.ABCIApplication.ts b/__fixtures__/output1/tendermint/abci/types.rpc.ABCIApplication.ts index c8702b7e71..961c2de491 100644 --- a/__fixtures__/output1/tendermint/abci/types.rpc.ABCIApplication.ts +++ b/__fixtures__/output1/tendermint/abci/types.rpc.ABCIApplication.ts @@ -5,7 +5,9 @@ import { EvidenceParams, EvidenceParamsSDKType, ValidatorParams, ValidatorParams import { PublicKey, PublicKeySDKType } from "../crypto/keys"; import { Rpc } from "../../helpers"; import * as _m0 from "protobufjs/minimal"; -import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate"; +import { ReactQueryParams } from "../../react-query"; +import { useQuery } from "@tanstack/react-query"; import { RequestEcho, RequestEchoSDKType, ResponseEcho, ResponseEchoSDKType, RequestFlush, RequestFlushSDKType, ResponseFlush, ResponseFlushSDKType, RequestInfo, RequestInfoSDKType, ResponseInfo, ResponseInfoSDKType, RequestSetOption, RequestSetOptionSDKType, ResponseSetOption, ResponseSetOptionSDKType, RequestDeliverTx, RequestDeliverTxSDKType, ResponseDeliverTx, ResponseDeliverTxSDKType, RequestCheckTx, RequestCheckTxSDKType, ResponseCheckTx, ResponseCheckTxSDKType, RequestQuery, RequestQuerySDKType, ResponseQuery, ResponseQuerySDKType, RequestCommit, RequestCommitSDKType, ResponseCommit, ResponseCommitSDKType, RequestInitChain, RequestInitChainSDKType, ResponseInitChain, ResponseInitChainSDKType, RequestBeginBlock, RequestBeginBlockSDKType, ResponseBeginBlock, ResponseBeginBlockSDKType, RequestEndBlock, RequestEndBlockSDKType, ResponseEndBlock, ResponseEndBlockSDKType, RequestListSnapshots, RequestListSnapshotsSDKType, ResponseListSnapshots, ResponseListSnapshotsSDKType, RequestOfferSnapshot, RequestOfferSnapshotSDKType, ResponseOfferSnapshot, ResponseOfferSnapshotSDKType, RequestLoadSnapshotChunk, RequestLoadSnapshotChunkSDKType, ResponseLoadSnapshotChunk, ResponseLoadSnapshotChunkSDKType, RequestApplySnapshotChunk, RequestApplySnapshotChunkSDKType, ResponseApplySnapshotChunk, ResponseApplySnapshotChunkSDKType } from "./types"; export interface ABCIApplication { echo(request: RequestEcho): Promise; @@ -202,4 +204,237 @@ export const createRpcQueryExtension = (base: QueryClient) => { } }; +}; +export interface UseEchoQuery extends ReactQueryParams { + request: RequestEcho; +} +export interface UseFlushQuery extends ReactQueryParams { + request?: RequestFlush; +} +export interface UseInfoQuery extends ReactQueryParams { + request: RequestInfo; +} +export interface UseSetOptionQuery extends ReactQueryParams { + request: RequestSetOption; +} +export interface UseDeliverTxQuery extends ReactQueryParams { + request: RequestDeliverTx; +} +export interface UseCheckTxQuery extends ReactQueryParams { + request: RequestCheckTx; +} +export interface UseQueryQuery extends ReactQueryParams { + request: RequestQuery; +} +export interface UseCommitQuery extends ReactQueryParams { + request?: RequestCommit; +} +export interface UseInitChainQuery extends ReactQueryParams { + request: RequestInitChain; +} +export interface UseBeginBlockQuery extends ReactQueryParams { + request: RequestBeginBlock; +} +export interface UseEndBlockQuery extends ReactQueryParams { + request: RequestEndBlock; +} +export interface UseListSnapshotsQuery extends ReactQueryParams { + request?: RequestListSnapshots; +} +export interface UseOfferSnapshotQuery extends ReactQueryParams { + request: RequestOfferSnapshot; +} +export interface UseLoadSnapshotChunkQuery extends ReactQueryParams { + request: RequestLoadSnapshotChunk; +} +export interface UseApplySnapshotChunkQuery extends ReactQueryParams { + request: RequestApplySnapshotChunk; +} + +const _queryClients: WeakMap = new WeakMap(); + +const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => { + if (!rpc) return; + + if (_queryClients.has(rpc)) { + return _queryClients.get(rpc); + } + + const queryService = new QueryClientImpl(rpc); + + _queryClients.set(rpc, queryService); + + return queryService; +}; + +export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useEcho = ({ + request, + options + }: UseEchoQuery) => { + return useQuery(["echoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.echo(request); + }, options); + }; + + const useFlush = ({ + request, + options + }: UseFlushQuery) => { + return useQuery(["flushQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.flush(request); + }, options); + }; + + const useInfo = ({ + request, + options + }: UseInfoQuery) => { + return useQuery(["infoQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.info(request); + }, options); + }; + + const useSetOption = ({ + request, + options + }: UseSetOptionQuery) => { + return useQuery(["setOptionQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.setOption(request); + }, options); + }; + + const useDeliverTx = ({ + request, + options + }: UseDeliverTxQuery) => { + return useQuery(["deliverTxQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.deliverTx(request); + }, options); + }; + + const useCheckTx = ({ + request, + options + }: UseCheckTxQuery) => { + return useQuery(["checkTxQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.checkTx(request); + }, options); + }; + + const useQuery = ({ + request, + options + }: UseQueryQuery) => { + return useQuery(["queryQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.query(request); + }, options); + }; + + const useCommit = ({ + request, + options + }: UseCommitQuery) => { + return useQuery(["commitQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.commit(request); + }, options); + }; + + const useInitChain = ({ + request, + options + }: UseInitChainQuery) => { + return useQuery(["initChainQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.initChain(request); + }, options); + }; + + const useBeginBlock = ({ + request, + options + }: UseBeginBlockQuery) => { + return useQuery(["beginBlockQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.beginBlock(request); + }, options); + }; + + const useEndBlock = ({ + request, + options + }: UseEndBlockQuery) => { + return useQuery(["endBlockQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.endBlock(request); + }, options); + }; + + const useListSnapshots = ({ + request, + options + }: UseListSnapshotsQuery) => { + return useQuery(["listSnapshotsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.listSnapshots(request); + }, options); + }; + + const useOfferSnapshot = ({ + request, + options + }: UseOfferSnapshotQuery) => { + return useQuery(["offerSnapshotQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.offerSnapshot(request); + }, options); + }; + + const useLoadSnapshotChunk = ({ + request, + options + }: UseLoadSnapshotChunkQuery) => { + return useQuery(["loadSnapshotChunkQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.loadSnapshotChunk(request); + }, options); + }; + + const useApplySnapshotChunk = ({ + request, + options + }: UseApplySnapshotChunkQuery) => { + return useQuery(["applySnapshotChunkQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.applySnapshotChunk(request); + }, options); + }; + + return { + useEcho, + useFlush, + useInfo, + useSetOption, + useDeliverTx, + useCheckTx, + useQuery, + useCommit, + useInitChain, + useBeginBlock, + useEndBlock, + useListSnapshots, + useOfferSnapshot, + useLoadSnapshotChunk, + useApplySnapshotChunk + }; }; \ No newline at end of file diff --git a/__fixtures__/output2/extern.ts b/__fixtures__/output2/extern.ts new file mode 100644 index 0000000000..c00714d1bf --- /dev/null +++ b/__fixtures__/output2/extern.ts @@ -0,0 +1,35 @@ +//@ts-nocheck +/* eslint-disable */ +/** +* This file and any referenced files were automatically generated by @osmonauts/telescope@latest +* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain +* and run the transpile command or yarn proto command to regenerate this bundle. +*/ + +import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from '@cosmjs/stargate' +import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc"; + +const _rpcClients: Record = {}; + +export const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => { + if (typeof rpcEndpoint === 'string') { + return rpcEndpoint; + } else if (!!rpcEndpoint) { + //@ts-ignore + return rpcEndpoint.url; + } +} + +export const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => { + const key = getRpcEndpointKey(rpcEndpoint); + if (!key) return; + if (_rpcClients.hasOwnProperty(key)) { + return _rpcClients[key]; + } + const tmClient = await Tendermint34Client.connect(rpcEndpoint); + //@ts-ignore + const client = new QueryClient(tmClient); + const rpc = createProtobufRpcClient(client); + _rpcClients[key] = rpc; + return rpc; +} diff --git a/__fixtures__/output2/helpers.ts b/__fixtures__/output2/helpers.ts index 806f65baff..bc208fdbcb 100644 --- a/__fixtures__/output2/helpers.ts +++ b/__fixtures__/output2/helpers.ts @@ -1,11 +1,11 @@ //@ts-nocheck /* eslint-disable */ /** - * This file and any referenced files were automatically generated by @osmonauts/telescope@latest - * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain - * and run the transpile command or yarn proto command to regenerate this bundle. - */ - +* This file and any referenced files were automatically generated by @osmonauts/telescope@latest +* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain +* and run the transpile command or yarn proto command to regenerate this bundle. +*/ + import * as _m0 from "protobufjs/minimal"; import Long from 'long'; diff --git a/packages/ast/src/index.ts b/packages/ast/src/index.ts index 124911489d..4d859189cf 100644 --- a/packages/ast/src/index.ts +++ b/packages/ast/src/index.ts @@ -3,4 +3,5 @@ export * from './clients'; export * from './registry'; export * from './utils'; export * from './bundle'; +export * from './state'; export * from './types'; \ No newline at end of file diff --git a/packages/ast/src/state/index.ts b/packages/ast/src/state/index.ts new file mode 100644 index 0000000000..0dd2cb576d --- /dev/null +++ b/packages/ast/src/state/index.ts @@ -0,0 +1 @@ +export * from './react-query'; \ No newline at end of file diff --git a/packages/ast/src/state/react-query/__snapshots__/react-query.scoped.test.ts.snap b/packages/ast/src/state/react-query/__snapshots__/react-query.scoped.test.ts.snap new file mode 100644 index 0000000000..ecf0d8c94f --- /dev/null +++ b/packages/ast/src/state/react-query/__snapshots__/react-query.scoped.test.ts.snap @@ -0,0 +1,28 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`createScopedRpcHookFactory 1`] = ` +"import * as _ProtoCosmosBankV1beta1A from "./proto/cosmos/bank/v1beta1/a.lcd"; +import * as _ProtoCosmosBankV1beta1B from "./proto/cosmos/bank/v1beta1/b.lcd"; +import * as _ProtoCosmosBankV1beta1C from "./proto/cosmos/bank/v1beta1/c.lcd"; +export const createRpcFactorizzle = ({ + rpc +}: { + rpc: ProtobufRpcClient | undefined; +}) => { + return { + cosmos: { + bank: { + v1beta1: _ProtoCosmosBankV1beta1A.createRpcQueryHooks(rpc) + }, + gov: { + v1beta1: _ProtoCosmosBankV1beta1B.createRpcQueryHooks(rpc) + } + }, + osmosis: { + gamm: { + v1beta1: _ProtoCosmosBankV1beta1C.createRpcQueryHooks(rpc) + } + } + }; +};" +`; diff --git a/packages/ast/src/state/react-query/__snapshots__/react-query.test.ts.snap b/packages/ast/src/state/react-query/__snapshots__/react-query.test.ts.snap new file mode 100644 index 0000000000..de32eb13fc --- /dev/null +++ b/packages/ast/src/state/react-query/__snapshots__/react-query.test.ts.snap @@ -0,0 +1,128 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`createRpcQueryHookInterfaces 1`] = ` +"export interface UseAccountsQuery extends ReactQueryParams { + request?: QueryAccountsRequest; +} +export interface UseAccountQuery extends ReactQueryParams { + request: QueryAccountRequest; +} +export interface UseParamsQuery extends ReactQueryParams { + request?: QueryParamsRequest; +} +export interface UseModuleAccountsQuery extends ReactQueryParams { + request?: QueryModuleAccountsRequest; +} +export interface UseBech32PrefixQuery extends ReactQueryParams { + request?: Bech32PrefixRequest; +} +export interface UseAddressBytesToStringQuery extends ReactQueryParams { + request: AddressBytesToStringRequest; +} +export interface UseAddressStringToBytesQuery extends ReactQueryParams { + request: AddressStringToBytesRequest; +}" +`; + +exports[`createRpcQueryHooks 1`] = ` +"export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => { + const queryService = getQueryService(rpc); + + const useAccounts = ({ + request, + options + }: UseAccountsQuery) => { + return useQuery(["accountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.accounts(request); + }, options); + }; + + const useAccount = ({ + request, + options + }: UseAccountQuery) => { + return useQuery(["accountQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.account(request); + }, options); + }; + + const useParams = ({ + request, + options + }: UseParamsQuery) => { + return useQuery(["paramsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.params(request); + }, options); + }; + + const useModuleAccounts = ({ + request, + options + }: UseModuleAccountsQuery) => { + return useQuery(["moduleAccountsQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.moduleAccounts(request); + }, options); + }; + + const useBech32Prefix = ({ + request, + options + }: UseBech32PrefixQuery) => { + return useQuery(["bech32PrefixQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.bech32Prefix(request); + }, options); + }; + + const useAddressBytesToString = ({ + request, + options + }: UseAddressBytesToStringQuery) => { + return useQuery(["addressBytesToStringQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.addressBytesToString(request); + }, options); + }; + + const useAddressStringToBytes = ({ + request, + options + }: UseAddressStringToBytesQuery) => { + return useQuery(["addressStringToBytesQuery", request], () => { + if (!queryService) throw new Error("Query Service not initialized"); + return queryService.addressStringToBytes(request); + }, options); + }; + + return { + /** + * Accounts returns all the existing accounts + * + * Since: cosmos-sdk 0.43 + */ + useAccounts, + + /** Account returns account details based on address. */ + useAccount, + + /** Params queries all parameters. */ + useParams, + + /** ModuleAccounts returns all the existing module accounts. */ + useModuleAccounts, + + /** Bech32 queries bech32Prefix */ + useBech32Prefix, + + /** AddressBytesToString converts Account Address bytes to string */ + useAddressBytesToString, + + /** AddressStringToBytes converts Address string to bytes */ + useAddressStringToBytes + }; +};" +`; diff --git a/packages/ast/src/state/react-query/index.ts b/packages/ast/src/state/react-query/index.ts new file mode 100644 index 0000000000..ae01c209cd --- /dev/null +++ b/packages/ast/src/state/react-query/index.ts @@ -0,0 +1,2 @@ +export * from './react-query'; +export * from './scoped-bundle'; \ No newline at end of file diff --git a/packages/ast/src/state/react-query/react-query.scoped.test.ts b/packages/ast/src/state/react-query/react-query.scoped.test.ts new file mode 100644 index 0000000000..37ae1e5886 --- /dev/null +++ b/packages/ast/src/state/react-query/react-query.scoped.test.ts @@ -0,0 +1,33 @@ +import { expectCode, getGenericParseContext, getTestProtoStore } from '../../../test-utils'; +import * as t from '@babel/types'; +import { createScopedRpcHookFactory } from './scoped-bundle'; + +const store = getTestProtoStore(); +store.traverseAll(); + +it('createScopedRpcHookFactory', async () => { + const context = getGenericParseContext(); + expectCode( + t.program( + createScopedRpcHookFactory( + context, + { + cosmos: { + bank: { + v1beta1: "./proto/cosmos/bank/v1beta1/a.lcd" + }, + gov: { + v1beta1: "./proto/cosmos/bank/v1beta1/b.lcd" + }, + }, + osmosis: { + gamm: { + v1beta1: "./proto/cosmos/bank/v1beta1/c.lcd" + } + } + }, + 'createRpcFactorizzle', + ) as t.Statement[] + ) + ) +}); diff --git a/packages/ast/src/state/react-query/react-query.test.ts b/packages/ast/src/state/react-query/react-query.test.ts new file mode 100644 index 0000000000..51828a8865 --- /dev/null +++ b/packages/ast/src/state/react-query/react-query.test.ts @@ -0,0 +1,28 @@ +import { traverse, getNestedProto } from '@osmonauts/proto-parser' +import { defaultTelescopeOptions, ProtoService } from '@osmonauts/types'; +import { expectCode, getTestProtoStore } from '../../../test-utils'; +import { GenericParseContext } from '../../encoding'; +import { createRpcQueryHooks, createRpcQueryHookInterfaces } from './react-query'; +import * as t from '@babel/types'; + +const store = getTestProtoStore(); +store.traverseAll(); + +it('createRpcQueryHooks', () => { + const ref = store.findProto('cosmos/auth/v1beta1/query.proto'); + const res = traverse(store, ref); + const service: ProtoService = getNestedProto(res).Query; + const context = new GenericParseContext(ref, store, defaultTelescopeOptions); + expectCode(createRpcQueryHooks(context, service)) +}); + +it('createRpcQueryHookInterfaces', () => { + const ref = store.findProto('cosmos/auth/v1beta1/query.proto'); + const res = traverse(store, ref); + const service: ProtoService = getNestedProto(res).Query; + const context = new GenericParseContext(ref, store, defaultTelescopeOptions); + expectCode(t.program([ + ...createRpcQueryHookInterfaces(context, service) + ])) +}); + diff --git a/packages/ast/src/state/react-query/react-query.ts b/packages/ast/src/state/react-query/react-query.ts new file mode 100644 index 0000000000..53e6ff018e --- /dev/null +++ b/packages/ast/src/state/react-query/react-query.ts @@ -0,0 +1,283 @@ + +import * as t from '@babel/types'; +import { arrowFunctionExpression, callExpression, identifier, makeCommentBlock, makeCommentLineWithBlocks, objectMethod, objectPattern, objectProperty, tsPropertySignature, tsTypeParameterDeclaration } from '../../utils'; +import { ProtoService, ProtoServiceMethod } from '@osmonauts/types'; +import { GenericParseContext } from '../../encoding'; +import { camel } from '@osmonauts/utils'; +import { pascal } from 'case'; +import { clientMap } from './weak-map'; + +const makeUseHookName = (name: string) => { + return camel('use_' + name); +}; + +const makeUseHookTypeName = (name: string) => { + return pascal('Use_' + name + 'Query'); +}; + +const makeHookKeyName = (name: string) => { + return camel(name + 'Query'); +}; + +const rpcHookMethod = ( + context: GenericParseContext, + name: string, + svc: ProtoServiceMethod +) => { + const requestType = svc.requestType; + const responseType = svc.responseType; + const fieldNames = Object.keys(svc.fields ?? {}) + const hasParams = fieldNames.length > 0; + + let optional = false; + // // if no params, then let's default to empty object for cleaner API + if (!hasParams) { + optional = true; + } else if (hasParams && fieldNames.length === 1 && fieldNames.includes('pagination')) { + // if only argument "required" is pagination + // also default to empty + optional = true; + } + + context.addUtil('useQuery'); + + return t.variableDeclaration('const', [ + t.variableDeclarator( + t.identifier(makeUseHookName(name)), + arrowFunctionExpression([ + objectPattern([ + t.objectProperty( + t.identifier('request'), + t.identifier('request'), + false, + true + ), + t.objectProperty( + t.identifier('options'), + t.identifier('options'), + false, + true + ) + ], + t.tsTypeAnnotation( + t.tsTypeReference( + t.identifier(makeUseHookTypeName(name)), + t.tsTypeParameterInstantiation([ + t.tsTypeReference( + t.identifier('TData') + ) + ]) + ) + ) + ) + ], + t.blockStatement([ + t.returnStatement( + callExpression( + t.identifier('useQuery'), + [ + t.arrayExpression([ + t.stringLiteral(makeHookKeyName(name)), + t.identifier('request') + ]), + t.arrowFunctionExpression( + [], + t.blockStatement([ + t.ifStatement(t.unaryExpression('!', t.identifier('queryService'), true), t.throwStatement( + t.newExpression(t.identifier('Error'), [ + t.stringLiteral('Query Service not initialized') + ]) + )), + t.returnStatement( + t.callExpression(t.memberExpression(t.identifier('queryService'), t.identifier(name)), [ + t.identifier('request') + ]) + ) + ]) + ), + t.identifier('options') + ], + t.tsTypeParameterInstantiation([ + t.tsTypeReference(t.identifier(responseType)), + t.tsTypeReference(t.identifier('Error')), + t.tsTypeReference(t.identifier('TData')) + ]) + )) + ]), + null, + false, + tsTypeParameterDeclaration([ + t.tsTypeParameter(null, t.tsTypeReference(t.identifier(responseType)), 'TData') + ]) + ) + ) + ]); + +} + +const rpcHookMethodInterface = ( + context: GenericParseContext, + name: string, + svc: ProtoServiceMethod +) => { + const requestType = svc.requestType; + const responseType = svc.responseType; + const fieldNames = Object.keys(svc.fields ?? {}) + const hasParams = fieldNames.length > 0; + + let optional = false; + // // if no params, then let's default to empty object for cleaner API + if (!hasParams) { + optional = true; + } else if (hasParams && fieldNames.length === 1 && fieldNames.includes('pagination')) { + // if only argument "required" is pagination + // also default to empty + optional = true; + } + + context.addUtil('ReactQueryParams'); + + return t.exportNamedDeclaration(t.tsInterfaceDeclaration( + t.identifier(makeUseHookTypeName(name)), + t.tsTypeParameterDeclaration([ + t.tsTypeParameter(null, null, 'TData') + ]), + [ + t.tsExpressionWithTypeArguments( + t.identifier('ReactQueryParams'), + t.tsTypeParameterInstantiation([ + t.tsTypeReference(t.identifier(responseType)), + t.tsTypeReference(t.identifier('TData')) + ]) + ) + ], + t.tsInterfaceBody([ + tsPropertySignature( + t.identifier('request'), + t.tsTypeAnnotation( + t.tsTypeReference( + t.identifier(requestType) + ) + ), + optional + ) + ]) + )); +} + +export const createRpcQueryHooks = ( + context: GenericParseContext, + service: ProtoService +) => { + + context.addUtil('QueryClient'); + context.addUtil('createProtobufRpcClient'); + context.addUtil('ProtobufRpcClient'); + + const camelRpcMethods = context.pluginValue('rpcClients.camelCase'); + // const name = service.name + 'ClientImpl'; + // const implementsName = service.name; + // const methodNames = Object.keys(service.methods ?? {}) + // .map(key => { + // return camelRpcMethods ? camel(key) : key + // }); + const methods = Object.keys(service.methods ?? {}) + .map(key => { + const method = service.methods[key]; + const name = camelRpcMethods ? camel(key) : key; + return rpcHookMethod( + context, + name, + method + ) + }); + + const methodNames = Object.keys(service.methods ?? {}) + .map(key => { + const name = camelRpcMethods ? camel(key) : key; + return { + name, + comment: service.methods[key].comment + }; + }); + + return t.exportNamedDeclaration( + t.variableDeclaration('const', [ + t.variableDeclarator( + t.identifier('createRpcQueryHooks'), + t.arrowFunctionExpression([ + identifier('rpc', t.tsTypeAnnotation( + t.tsUnionType([ + t.tsTypeReference(t.identifier('ProtobufRpcClient')), + t.tsUndefinedKeyword() + ]) + ))], + + // body + t.blockStatement([ + + // query service + t.variableDeclaration('const', [ + t.variableDeclarator( + t.identifier('queryService'), + t.callExpression( + t.identifier('getQueryService'), + [ + t.identifier('rpc') + ] + ) + ) + ]), + + + ...methods, + + // return the methods... + t.returnStatement( + t.objectExpression( + methodNames.map(({ name, comment }) => + objectProperty( + t.identifier(makeUseHookName(name)), + t.identifier(makeUseHookName(name)), + false, + true, + null, + makeCommentLineWithBlocks(comment) + ) + ) + ) + ) + ]) + // end body + + ) + ) + ]) + ); +}; + + + +export const createRpcQueryHookInterfaces = ( + context: GenericParseContext, + service: ProtoService +) => { + + + const camelRpcMethods = context.pluginValue('rpcClients.camelCase'); + + const methods = Object.keys(service.methods ?? {}) + .map(key => { + const name = camelRpcMethods ? camel(key) : key; + const method = service.methods[key]; + return { + name, + method + }; + }); + + return methods.map(method => rpcHookMethodInterface(context, method.name, method.method)); +}; + +export const createRpcQueryHookClientMap = () => clientMap; + diff --git a/packages/ast/src/state/react-query/scoped-bundle.ts b/packages/ast/src/state/react-query/scoped-bundle.ts new file mode 100644 index 0000000000..947bc57caa --- /dev/null +++ b/packages/ast/src/state/react-query/scoped-bundle.ts @@ -0,0 +1,200 @@ +import * as t from '@babel/types'; +import { GenericParseContext } from '../../encoding'; +import { objectPattern } from '../../utils'; +import { variableSlug } from '@osmonauts/utils'; + +export const rpcHookFuncArguments = (): t.ObjectPattern[] => { + return [ + objectPattern( + [ + t.objectProperty( + t.identifier('rpc'), + t.identifier('rpc'), + false, + true + ) + ], + t.tsTypeAnnotation( + t.tsTypeLiteral( + [ + t.tsPropertySignature( + t.identifier('rpc'), + t.tsTypeAnnotation( + t.tsTypeReference( + t.identifier('Rpc') + ) + ) + ) + ] + ) + ) + ) + ]; +}; + +export const rpcHookClassArguments = (): t.ObjectExpression[] => { + return [ + t.objectExpression( + [ + t.objectProperty( + t.identifier('rpc'), + t.identifier('rpc'), + false, + true + ) + ] + ) + ]; +}; + +export const rpcHookNewTmRequire = ( + imports: HookImport[], + path: string, + methodName: string +) => { + + imports.push({ + as: variableSlug(path), + path + }); + + return t.callExpression( + t.memberExpression( + t.identifier(variableSlug(path)), + t.identifier(methodName) + ), + [ + t.identifier('rpc') + ] + ) + +} + +export const rpcHookRecursiveObjectProps = ( + names: string[], + leaf?: any +) => { + const [name, ...rest] = names; + + let baseComponent; + if (names.length === 1) { + baseComponent = leaf ? leaf : t.identifier(name) + } else { + baseComponent = rpcHookRecursiveObjectProps(rest, leaf) + } + + return t.objectExpression([ + t.objectProperty( + t.identifier(name), + baseComponent + ) + ]) +}; + +export const rpcHookTmNestedImportObject = ( + imports: HookImport[], + obj: object, + methodName: string +) => { + + if (typeof obj === 'string') { + return rpcHookNewTmRequire(imports, obj, methodName); + } + + const keys = Object.keys(obj); + + return t.objectExpression(keys.map(name => { + return t.objectProperty( + t.identifier(name), + rpcHookTmNestedImportObject(imports, obj[name], methodName) + ) + })) +}; + +interface HookImport { + as: string; + path: string; +} + +export const createScopedRpcHookFactory = ( + context: GenericParseContext, + obj: object, + identifier: string +) => { + + context.addUtil('ProtobufRpcClient'); + + const hookImports: HookImport[] = []; + + const ast = t.exportNamedDeclaration( + t.variableDeclaration( + 'const', + [ + t.variableDeclarator( + // createRPCQueryHooks + t.identifier(identifier), + t.arrowFunctionExpression( + [ + objectPattern([ + t.objectProperty( + t.identifier('rpc'), + t.identifier('rpc'), + false, + true + ) + ], t.tsTypeAnnotation( + t.tsTypeLiteral([ + t.tsPropertySignature( + t.identifier('rpc'), + t.tsTypeAnnotation( + t.tsUnionType([ + t.tsTypeReference( + t.identifier('ProtobufRpcClient') + ), + t.tsUndefinedKeyword() + ]) + ) + ) + ]) + )) + ], + t.blockStatement([ + + t.returnStatement( + rpcHookTmNestedImportObject( + hookImports, + obj, + 'createRpcQueryHooks' + ) + ) + + ]), + false + ) + ) + ] + ) + ); + + const imports = hookImports.map(hookport => { + return { + "type": "ImportDeclaration", + "importKind": "value", + "specifiers": [ + { + "type": "ImportNamespaceSpecifier", + "local": { + "type": "Identifier", + "name": hookport.as + } + } + ], + "source": { + "type": "StringLiteral", + "value": hookport.path + } + }; + }); + + return [...imports, ast]; +}; diff --git a/packages/ast/src/state/react-query/weak-map.ts b/packages/ast/src/state/react-query/weak-map.ts new file mode 100644 index 0000000000..6590081296 --- /dev/null +++ b/packages/ast/src/state/react-query/weak-map.ts @@ -0,0 +1,252 @@ +export const clientMap = [ + { + "type": "VariableDeclaration", + "declarations": [ + { + "type": "VariableDeclarator", + "id": { + "type": "Identifier", + "name": "_queryClients", + "typeAnnotation": { + "type": "TSTypeAnnotation", + "typeAnnotation": { + "type": "TSTypeReference", + "typeName": { + "type": "Identifier", + "name": "WeakMap" + }, + "typeParameters": { + "type": "TSTypeParameterInstantiation", + "params": [ + { + "type": "TSTypeReference", + "typeName": { + "type": "Identifier", + "name": "ProtobufRpcClient" + } + }, + { + "type": "TSTypeReference", + "typeName": { + "type": "Identifier", + "name": "QueryClientImpl" + } + } + ] + } + } + } + }, + "init": { + "type": "NewExpression", + "callee": { + "type": "Identifier", + "name": "WeakMap" + }, + "arguments": [] + } + } + ], + "kind": "const" + }, + { + "type": "VariableDeclaration", + "declarations": [ + { + "type": "VariableDeclarator", + "id": { + "type": "Identifier", + "name": "getQueryService" + }, + "init": { + "type": "ArrowFunctionExpression", + "returnType": { + "type": "TSTypeAnnotation", + "typeAnnotation": { + "type": "TSUnionType", + "types": [ + { + "type": "TSTypeReference", + "typeName": { + "type": "Identifier", + "name": "QueryClientImpl" + } + }, + { + "type": "TSUndefinedKeyword" + } + ] + } + }, + "id": null, + "generator": false, + "async": false, + "params": [ + { + "type": "Identifier", + "name": "rpc", + "typeAnnotation": { + "type": "TSTypeAnnotation", + "typeAnnotation": { + "type": "TSUnionType", + "types": [ + { + "type": "TSTypeReference", + "typeName": { + "type": "Identifier", + "name": "ProtobufRpcClient" + } + }, + { + "type": "TSUndefinedKeyword" + } + ] + } + } + } + ], + "body": { + "type": "BlockStatement", + "body": [ + { + "type": "IfStatement", + "test": { + "type": "UnaryExpression", + "operator": "!", + "prefix": true, + "argument": { + "type": "Identifier", + "name": "rpc" + } + }, + "consequent": { + "type": "ReturnStatement", + "argument": null + }, + "alternate": null + }, + { + "type": "IfStatement", + "test": { + "type": "CallExpression", + "callee": { + "type": "MemberExpression", + "object": { + "type": "Identifier", + "name": "_queryClients" + }, + "computed": false, + "property": { + "type": "Identifier", + "name": "has" + } + }, + "arguments": [ + { + "type": "Identifier", + "name": "rpc" + } + ] + }, + "consequent": { + "type": "BlockStatement", + "body": [ + { + "type": "ReturnStatement", + "argument": { + "type": "CallExpression", + "callee": { + "type": "MemberExpression", + "object": { + "type": "Identifier", + "name": "_queryClients" + }, + "computed": false, + "property": { + "type": "Identifier", + "name": "get" + } + }, + "arguments": [ + { + "type": "Identifier", + "name": "rpc" + } + ] + } + } + ], + "directives": [] + }, + "alternate": null + }, + { + "type": "VariableDeclaration", + "declarations": [ + { + "type": "VariableDeclarator", + "id": { + "type": "Identifier", + "name": "queryService" + }, + "init": { + "type": "NewExpression", + "callee": { + "type": "Identifier", + "name": "QueryClientImpl" + }, + "arguments": [ + { + "type": "Identifier", + "name": "rpc" + } + ] + } + } + ], + "kind": "const" + }, + { + "type": "ExpressionStatement", + "expression": { + "type": "CallExpression", + "callee": { + "type": "MemberExpression", + "object": { + "type": "Identifier", + "name": "_queryClients" + }, + "computed": false, + "property": { + "type": "Identifier", + "name": "set" + } + }, + "arguments": [ + { + "type": "Identifier", + "name": "rpc" + }, + { + "type": "Identifier", + "name": "queryService" + } + ] + } + }, + { + "type": "ReturnStatement", + "argument": { + "type": "Identifier", + "name": "queryService" + } + } + ], + "directives": [] + } + } + } + ], + "kind": "const" + } +] \ No newline at end of file diff --git a/packages/ast/src/utils/babel.ts b/packages/ast/src/utils/babel.ts index 50a2f689fe..5c81992ed3 100644 --- a/packages/ast/src/utils/babel.ts +++ b/packages/ast/src/utils/babel.ts @@ -1,4 +1,5 @@ import * as t from '@babel/types'; +import { makeCommentBlock } from './utils'; // TODO move to @osmonauts/utils package @@ -150,14 +151,22 @@ export function classProperty( export const arrowFunctionExpression = ( params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, - returnType: t.TSTypeAnnotation, - isAsync: boolean = false + returnType?: t.TSTypeAnnotation, + isAsync: boolean = false, + typeParameters?: t.TypeParameterDeclaration | t.TSTypeParameterDeclaration | t.Noop ) => { const func = t.arrowFunctionExpression(params, body, isAsync); - if (returnType) func.returnType = returnType; + func.returnType = returnType; + func.typeParameters = typeParameters; return func; }; +export const tsTypeParameterDeclaration = (params: Array): t.TSTypeParameterDeclaration => { + const obj = t.tsTypeParameterDeclaration(params); + delete obj.extra; + return obj; +}; + export const objectPattern = ( properties: (t.RestElement | t.ObjectProperty)[], typeAnnotation: t.TSTypeAnnotation @@ -183,5 +192,26 @@ export const objectMethod = obj.returnType = returnType; obj.typeParameters = typeParameters; return obj; - } + }; + +export const objectProperty = ( + key: t.Expression | t.Identifier | t.StringLiteral | t.NumericLiteral | t.BigIntLiteral | t.DecimalLiteral | t.PrivateName, + value: t.Expression | t.PatternLike, + computed?: boolean, + shorthand?: boolean, + decorators?: Array | null, + leadingComments: t.CommentLine[] = [] +): t.ObjectProperty => { + const obj = t.objectProperty(key, value, computed, shorthand, decorators); + if (leadingComments.length) obj.leadingComments = leadingComments; + return obj; +}; + +export const makeCommentLineWithBlocks = (comment: string): t.CommentLine[] => { + if (!comment) return []; + // NOTE using blocks instead of lines here... + // @ts-ignore + return [makeCommentBlock(comment)]; +} + diff --git a/packages/ast/types/src/index.d.ts b/packages/ast/types/src/index.d.ts index 44488f94de..6db2bbe63b 100644 --- a/packages/ast/types/src/index.d.ts +++ b/packages/ast/types/src/index.d.ts @@ -3,4 +3,5 @@ export * from './clients'; export * from './registry'; export * from './utils'; export * from './bundle'; +export * from './state'; export * from './types'; diff --git a/packages/ast/types/src/state/index.d.ts b/packages/ast/types/src/state/index.d.ts new file mode 100644 index 0000000000..82818ecb9d --- /dev/null +++ b/packages/ast/types/src/state/index.d.ts @@ -0,0 +1 @@ +export * from './react-query'; diff --git a/packages/ast/types/src/state/react-query/index.d.ts b/packages/ast/types/src/state/react-query/index.d.ts new file mode 100644 index 0000000000..866f901530 --- /dev/null +++ b/packages/ast/types/src/state/react-query/index.d.ts @@ -0,0 +1,2 @@ +export * from './react-query'; +export * from './scoped-bundle'; diff --git a/packages/ast/types/src/state/react-query/react-query.d.ts b/packages/ast/types/src/state/react-query/react-query.d.ts new file mode 100644 index 0000000000..b9cb1aba8b --- /dev/null +++ b/packages/ast/types/src/state/react-query/react-query.d.ts @@ -0,0 +1,246 @@ +import * as t from '@babel/types'; +import { ProtoService } from '@osmonauts/types'; +import { GenericParseContext } from '../../encoding'; +export declare const createRpcQueryHooks: (context: GenericParseContext, service: ProtoService) => t.ExportNamedDeclaration; +export declare const createRpcQueryHookInterfaces: (context: GenericParseContext, service: ProtoService) => t.ExportNamedDeclaration[]; +export declare const createRpcQueryHookClientMap: () => ({ + type: string; + declarations: { + type: string; + id: { + type: string; + name: string; + typeAnnotation: { + type: string; + typeAnnotation: { + type: string; + typeName: { + type: string; + name: string; + }; + typeParameters: { + type: string; + params: { + type: string; + typeName: { + type: string; + name: string; + }; + }[]; + }; + }; + }; + }; + init: { + type: string; + callee: { + type: string; + name: string; + }; + arguments: any[]; + }; + }[]; + kind: string; +} | { + type: string; + declarations: { + type: string; + id: { + type: string; + name: string; + }; + init: { + type: string; + returnType: { + type: string; + typeAnnotation: { + type: string; + types: ({ + type: string; + typeName: { + type: string; + name: string; + }; + } | { + type: string; + typeName?: undefined; + })[]; + }; + }; + id: any; + generator: boolean; + async: boolean; + params: { + type: string; + name: string; + typeAnnotation: { + type: string; + typeAnnotation: { + type: string; + types: ({ + type: string; + typeName: { + type: string; + name: string; + }; + } | { + type: string; + typeName?: undefined; + })[]; + }; + }; + }[]; + body: { + type: string; + body: ({ + type: string; + test: { + type: string; + operator: string; + prefix: boolean; + argument: { + type: string; + name: string; + }; + callee?: undefined; + arguments?: undefined; + }; + consequent: { + type: string; + argument: any; + body?: undefined; + directives?: undefined; + }; + alternate: any; + declarations?: undefined; + kind?: undefined; + expression?: undefined; + argument?: undefined; + } | { + type: string; + test: { + type: string; + callee: { + type: string; + object: { + type: string; + name: string; + }; + computed: boolean; + property: { + type: string; + name: string; + }; + }; + arguments: { + type: string; + name: string; + }[]; + operator?: undefined; + prefix?: undefined; + argument?: undefined; + }; + consequent: { + type: string; + body: { + type: string; + argument: { + type: string; + callee: { + type: string; + object: { + type: string; + name: string; + }; + computed: boolean; + property: { + type: string; + name: string; + }; + }; + arguments: { + type: string; + name: string; + }[]; + }; + }[]; + directives: any[]; + argument?: undefined; + }; + alternate: any; + declarations?: undefined; + kind?: undefined; + expression?: undefined; + argument?: undefined; + } | { + type: string; + declarations: { + type: string; + id: { + type: string; + name: string; + }; + init: { + type: string; + callee: { + type: string; + name: string; + }; + arguments: { + type: string; + name: string; + }[]; + }; + }[]; + kind: string; + test?: undefined; + consequent?: undefined; + alternate?: undefined; + expression?: undefined; + argument?: undefined; + } | { + type: string; + expression: { + type: string; + callee: { + type: string; + object: { + type: string; + name: string; + }; + computed: boolean; + property: { + type: string; + name: string; + }; + }; + arguments: { + type: string; + name: string; + }[]; + }; + test?: undefined; + consequent?: undefined; + alternate?: undefined; + declarations?: undefined; + kind?: undefined; + argument?: undefined; + } | { + type: string; + argument: { + type: string; + name: string; + }; + test?: undefined; + consequent?: undefined; + alternate?: undefined; + declarations?: undefined; + kind?: undefined; + expression?: undefined; + })[]; + directives: any[]; + }; + }; + }[]; + kind: string; +})[]; diff --git a/packages/ast/types/src/state/react-query/react-query.scoped.test.d.ts b/packages/ast/types/src/state/react-query/react-query.scoped.test.d.ts new file mode 100644 index 0000000000..cb0ff5c3b5 --- /dev/null +++ b/packages/ast/types/src/state/react-query/react-query.scoped.test.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/packages/ast/types/src/state/react-query/react-query.test.d.ts b/packages/ast/types/src/state/react-query/react-query.test.d.ts new file mode 100644 index 0000000000..cb0ff5c3b5 --- /dev/null +++ b/packages/ast/types/src/state/react-query/react-query.test.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/packages/ast/types/src/state/react-query/scoped-bundle.d.ts b/packages/ast/types/src/state/react-query/scoped-bundle.d.ts new file mode 100644 index 0000000000..27a35d132d --- /dev/null +++ b/packages/ast/types/src/state/react-query/scoped-bundle.d.ts @@ -0,0 +1,27 @@ +import * as t from '@babel/types'; +import { GenericParseContext } from '../../encoding'; +export declare const rpcHookFuncArguments: () => t.ObjectPattern[]; +export declare const rpcHookClassArguments: () => t.ObjectExpression[]; +export declare const rpcHookNewTmRequire: (imports: HookImport[], path: string, methodName: string) => t.CallExpression; +export declare const rpcHookRecursiveObjectProps: (names: string[], leaf?: any) => t.ObjectExpression; +export declare const rpcHookTmNestedImportObject: (imports: HookImport[], obj: object, methodName: string) => any; +interface HookImport { + as: string; + path: string; +} +export declare const createScopedRpcHookFactory: (context: GenericParseContext, obj: object, identifier: string) => (t.ExportNamedDeclaration | { + type: string; + importKind: string; + specifiers: { + type: string; + local: { + type: string; + name: string; + }; + }[]; + source: { + type: string; + value: string; + }; +})[]; +export {}; diff --git a/packages/ast/types/src/state/react-query/weak-map.d.ts b/packages/ast/types/src/state/react-query/weak-map.d.ts new file mode 100644 index 0000000000..5bf355aafe --- /dev/null +++ b/packages/ast/types/src/state/react-query/weak-map.d.ts @@ -0,0 +1,241 @@ +export declare const clientMap: ({ + type: string; + declarations: { + type: string; + id: { + type: string; + name: string; + typeAnnotation: { + type: string; + typeAnnotation: { + type: string; + typeName: { + type: string; + name: string; + }; + typeParameters: { + type: string; + params: { + type: string; + typeName: { + type: string; + name: string; + }; + }[]; + }; + }; + }; + }; + init: { + type: string; + callee: { + type: string; + name: string; + }; + arguments: any[]; + }; + }[]; + kind: string; +} | { + type: string; + declarations: { + type: string; + id: { + type: string; + name: string; + }; + init: { + type: string; + returnType: { + type: string; + typeAnnotation: { + type: string; + types: ({ + type: string; + typeName: { + type: string; + name: string; + }; + } | { + type: string; + typeName?: undefined; + })[]; + }; + }; + id: any; + generator: boolean; + async: boolean; + params: { + type: string; + name: string; + typeAnnotation: { + type: string; + typeAnnotation: { + type: string; + types: ({ + type: string; + typeName: { + type: string; + name: string; + }; + } | { + type: string; + typeName?: undefined; + })[]; + }; + }; + }[]; + body: { + type: string; + body: ({ + type: string; + test: { + type: string; + operator: string; + prefix: boolean; + argument: { + type: string; + name: string; + }; + callee?: undefined; + arguments?: undefined; + }; + consequent: { + type: string; + argument: any; + body?: undefined; + directives?: undefined; + }; + alternate: any; + declarations?: undefined; + kind?: undefined; + expression?: undefined; + argument?: undefined; + } | { + type: string; + test: { + type: string; + callee: { + type: string; + object: { + type: string; + name: string; + }; + computed: boolean; + property: { + type: string; + name: string; + }; + }; + arguments: { + type: string; + name: string; + }[]; + operator?: undefined; + prefix?: undefined; + argument?: undefined; + }; + consequent: { + type: string; + body: { + type: string; + argument: { + type: string; + callee: { + type: string; + object: { + type: string; + name: string; + }; + computed: boolean; + property: { + type: string; + name: string; + }; + }; + arguments: { + type: string; + name: string; + }[]; + }; + }[]; + directives: any[]; + argument?: undefined; + }; + alternate: any; + declarations?: undefined; + kind?: undefined; + expression?: undefined; + argument?: undefined; + } | { + type: string; + declarations: { + type: string; + id: { + type: string; + name: string; + }; + init: { + type: string; + callee: { + type: string; + name: string; + }; + arguments: { + type: string; + name: string; + }[]; + }; + }[]; + kind: string; + test?: undefined; + consequent?: undefined; + alternate?: undefined; + expression?: undefined; + argument?: undefined; + } | { + type: string; + expression: { + type: string; + callee: { + type: string; + object: { + type: string; + name: string; + }; + computed: boolean; + property: { + type: string; + name: string; + }; + }; + arguments: { + type: string; + name: string; + }[]; + }; + test?: undefined; + consequent?: undefined; + alternate?: undefined; + declarations?: undefined; + kind?: undefined; + argument?: undefined; + } | { + type: string; + argument: { + type: string; + name: string; + }; + test?: undefined; + consequent?: undefined; + alternate?: undefined; + declarations?: undefined; + kind?: undefined; + expression?: undefined; + })[]; + directives: any[]; + }; + }; + }[]; + kind: string; +})[]; diff --git a/packages/ast/types/src/utils/babel.d.ts b/packages/ast/types/src/utils/babel.d.ts index ba6b728f32..a9cf207eac 100644 --- a/packages/ast/types/src/utils/babel.d.ts +++ b/packages/ast/types/src/utils/babel.d.ts @@ -10,6 +10,9 @@ export declare const callExpression: (callee: t.Expression | t.V8IntrinsicIdenti export declare const identifier: (name: string, typeAnnotation: t.TSTypeAnnotation, optional?: boolean) => t.Identifier; export declare const classDeclaration: (id: t.Identifier, superClass: t.Expression | null | undefined, body: t.ClassBody, decorators?: Array | null, vImplements?: t.TSExpressionWithTypeArguments[]) => t.ClassDeclaration; export declare function classProperty(key: t.Identifier | t.StringLiteral | t.NumericLiteral | t.Expression, value?: t.Expression | null, typeAnnotation?: t.TypeAnnotation | t.TSTypeAnnotation | t.Noop | null, decorators?: Array | null, computed?: boolean, _static?: boolean, _readonly?: boolean, accessibility?: 'private' | 'protected' | 'public', leadingComments?: t.CommentLine[]): t.ClassProperty; -export declare const arrowFunctionExpression: (params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, returnType: t.TSTypeAnnotation, isAsync?: boolean) => t.ArrowFunctionExpression; +export declare const arrowFunctionExpression: (params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, returnType?: t.TSTypeAnnotation, isAsync?: boolean, typeParameters?: t.TypeParameterDeclaration | t.TSTypeParameterDeclaration | t.Noop) => t.ArrowFunctionExpression; +export declare const tsTypeParameterDeclaration: (params: Array) => t.TSTypeParameterDeclaration; export declare const objectPattern: (properties: (t.RestElement | t.ObjectProperty)[], typeAnnotation: t.TSTypeAnnotation) => t.ObjectPattern; export declare const objectMethod: (kind: "method" | "get" | "set", key: t.Expression, params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, computed?: boolean, generator?: boolean, async?: boolean, returnType?: t.TSTypeAnnotation | t.TypeAnnotation | t.Noop, typeParameters?: t.TypeParameterDeclaration | t.TSTypeParameterDeclaration | t.Noop) => t.ObjectMethod; +export declare const objectProperty: (key: t.Expression | t.Identifier | t.StringLiteral | t.NumericLiteral | t.BigIntLiteral | t.DecimalLiteral | t.PrivateName, value: t.Expression | t.PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array | null, leadingComments?: t.CommentLine[]) => t.ObjectProperty; +export declare const makeCommentLineWithBlocks: (comment: string) => t.CommentLine[]; diff --git a/packages/ast/types/test-utils/index.d.ts b/packages/ast/types/test-utils/index.d.ts index bac4a625f6..4e3f58850e 100644 --- a/packages/ast/types/test-utils/index.d.ts +++ b/packages/ast/types/test-utils/index.d.ts @@ -102,6 +102,9 @@ export declare const defaultTelescopeOptions: { methodNameTx?: string; }[]; }; + reactQuery: { + enabled: boolean; + }; packages: Record; } & { prototypes: { diff --git a/packages/telescope/__tests__/telescope.test.ts b/packages/telescope/__tests__/telescope.test.ts index bb1a1ddaee..cbf1ebf748 100644 --- a/packages/telescope/__tests__/telescope.test.ts +++ b/packages/telescope/__tests__/telescope.test.ts @@ -195,6 +195,10 @@ const options: TelescopeOptions = { ] }, + reactQuery: { + enabled: true + }, + aminoEncoding: { enabled: true, exceptions: { diff --git a/packages/telescope/src/builder.ts b/packages/telescope/src/builder.ts index d98aceff89..a1ba6d791d 100644 --- a/packages/telescope/src/builder.ts +++ b/packages/telescope/src/builder.ts @@ -17,6 +17,7 @@ import { plugin as createRPCQueryClientsScoped } from './generators/create-rpc-q import { plugin as createRPCMsgClientsScoped } from './generators/create-rpc-msg-client-scoped'; import { plugin as createRPCQueryClients } from './generators/create-rpc-query-clients'; import { plugin as createRPCMsgClients } from './generators/create-rpc-msg-clients'; +import { plugin as createReactQueryBundle } from './generators/create-react-query-bundle'; import { plugin as createStargateClients } from './generators/create-stargate-clients'; import { plugin as createBundle } from './generators/create-bundle'; import { plugin as createIndex } from './generators/create-index'; @@ -122,6 +123,7 @@ export class TelescopeBuilder { createBundle(this, bundler); }); + createReactQueryBundle(this); createAggregatedLCDClient(this); await createCosmWasmBundle(this); diff --git a/packages/telescope/src/generators/create-helpers.ts b/packages/telescope/src/generators/create-helpers.ts index 7ac9479d0a..639071d9b2 100644 --- a/packages/telescope/src/generators/create-helpers.ts +++ b/packages/telescope/src/generators/create-helpers.ts @@ -3,26 +3,35 @@ import { sync as mkdirp } from 'mkdirp'; import { TelescopeBuilder } from '../builder'; import pkg from '../../package.json'; import { writeContentToFile } from '../utils/files'; -import { helpers } from '../helpers'; +import { external, internal, reactQuery } from '../helpers'; const version = process.env.NODE_ENV === 'test' ? 'latest' : pkg.version; +const header = `/** +* This file and any referenced files were automatically generated by ${pkg.name}@${version} +* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain +* and run the transpile command or yarn proto command to regenerate this bundle. +*/ +\n`; -export const plugin = ( - builder: TelescopeBuilder +const write = ( + builder: TelescopeBuilder, + indexFile: string, + content: string ) => { - - const indexFile = 'helpers.ts'; const indexOutFile = join(builder.outPath, indexFile); - mkdirp(dirname(indexOutFile)); + writeContentToFile(builder.outPath, builder.options, header + content, indexOutFile); +} - const header = `/** - * This file and any referenced files were automatically generated by ${pkg.name}@${version} - * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain - * and run the transpile command or yarn proto command to regenerate this bundle. - */ - \n`; +export const plugin = ( + builder: TelescopeBuilder +) => { + write(builder, 'helpers.ts', internal); - writeContentToFile(builder.outPath, builder.options, header + helpers, indexOutFile); + // should be exported + write(builder, 'extern.ts', external); + if (builder.options.reactQuery.enabled) { + write(builder, 'react-query.ts', reactQuery); + } }; \ No newline at end of file diff --git a/packages/telescope/src/generators/create-react-query-bundle.ts b/packages/telescope/src/generators/create-react-query-bundle.ts new file mode 100644 index 0000000000..6744e5036e --- /dev/null +++ b/packages/telescope/src/generators/create-react-query-bundle.ts @@ -0,0 +1,70 @@ +import { aggregateImports, getImportStatements } from '../imports'; +import { join } from 'path'; +import { TelescopeBuilder } from '../builder'; +import { createScopedRpcHookFactory } from '@osmonauts/ast'; +import { ProtoRef } from '@osmonauts/types'; +import { TelescopeParseContext } from '../build'; +import { writeAstToFile } from '../utils/files'; +import { fixlocalpaths } from '../utils'; +import * as dotty from 'dotty'; + +export const plugin = ( + builder: TelescopeBuilder +) => { + + if (!builder.options.reactQuery.enabled) { + return; + } + + const localname = 'hooks.ts'; + + const obj = {}; + builder.rpcQueryClients.map(queryClient => { + const path = `./${queryClient.localname.replace(/\.ts$/, '')}`; + dotty.put(obj, queryClient.package, path); + }); + + const pkg = '@root'; + const ref: ProtoRef = { + absolute: '', + filename: localname, + proto: { + package: pkg, + imports: null, + root: {}, + importNames: null + }, + traversed: { + package: pkg, + imports: null, + root: {}, + importNames: null + } + } + + const pCtx = new TelescopeParseContext( + ref, + builder.store, + builder.options + ); + + const ast = createScopedRpcHookFactory( + pCtx.proto, + obj, + 'createRpcQueryHooks' + ) + + const imports = fixlocalpaths(aggregateImports(pCtx, {}, localname)); + const importStmts = getImportStatements( + localname, + imports + ); + + const prog = [] + .concat(importStmts) + .concat(ast); + + const filename = join(builder.outPath, localname); + writeAstToFile(builder.outPath, builder.options, prog, filename); + +}; \ No newline at end of file diff --git a/packages/telescope/src/generators/create-rpc-query-clients.ts b/packages/telescope/src/generators/create-rpc-query-clients.ts index b6465c9334..30165e074f 100644 --- a/packages/telescope/src/generators/create-rpc-query-clients.ts +++ b/packages/telescope/src/generators/create-rpc-query-clients.ts @@ -1,6 +1,13 @@ import { buildAllImports, getDepsFromQueries } from '../imports'; import { Bundler } from '../bundler'; -import { createRpcQueryExtension, createRpcClientClass, createRpcClientInterface } from '@osmonauts/ast'; +import { + createRpcQueryExtension, + createRpcClientClass, + createRpcClientInterface, + createRpcQueryHookInterfaces, + createRpcQueryHookClientMap, + createRpcQueryHooks +} from '@osmonauts/ast'; import { getNestedProto } from '@osmonauts/proto-parser'; import { parse } from '../parse'; import { TelescopeBuilder } from '../builder'; @@ -64,6 +71,14 @@ export const plugin = ( if (c.proto.pluginValue('rpcClients.extensions')) { asts.push(createRpcQueryExtension(ctx.generic, proto[svcKey])); } + + // react query + // TODO use the imports and make separate files + if (c.proto.pluginValue('reactQuery.enabled')) { + [].push.apply(asts, createRpcQueryHookInterfaces(ctx.generic, proto[svcKey])); + [].push.apply(asts, createRpcQueryHookClientMap()); + asts.push(createRpcQueryHooks(ctx.generic, proto[svcKey])); + } } }); diff --git a/packages/telescope/src/generators/create-stargate-clients.ts b/packages/telescope/src/generators/create-stargate-clients.ts index 21ea675663..bd5b37541a 100644 --- a/packages/telescope/src/generators/create-stargate-clients.ts +++ b/packages/telescope/src/generators/create-stargate-clients.ts @@ -11,7 +11,7 @@ import { } from '@osmonauts/ast'; import { ProtoRef } from '@osmonauts/types'; import { camel, pascal } from 'case'; -import { variableSlug } from '../utils'; +import { variableSlug } from '@osmonauts/utils'; import { buildAllImportsFromGenericContext } from '../imports'; export const plugin = ( diff --git a/packages/telescope/src/helpers/external.ts b/packages/telescope/src/helpers/external.ts new file mode 100644 index 0000000000..5835e2b4ce --- /dev/null +++ b/packages/telescope/src/helpers/external.ts @@ -0,0 +1,28 @@ +export const external = `import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from '@cosmjs/stargate' +import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc"; + +const _rpcClients: Record = {}; + +export const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => { + if (typeof rpcEndpoint === 'string') { + return rpcEndpoint; + } else if (!!rpcEndpoint) { + //@ts-ignore + return rpcEndpoint.url; + } +} + +export const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => { + const key = getRpcEndpointKey(rpcEndpoint); + if (!key) return; + if (_rpcClients.hasOwnProperty(key)) { + return _rpcClients[key]; + } + const tmClient = await Tendermint34Client.connect(rpcEndpoint); + //@ts-ignore + const client = new QueryClient(tmClient); + const rpc = createProtobufRpcClient(client); + _rpcClients[key] = rpc; + return rpc; +} +`; \ No newline at end of file diff --git a/packages/telescope/src/helpers/index.ts b/packages/telescope/src/helpers/index.ts index 0c047a650f..2ff700bcdb 100644 --- a/packages/telescope/src/helpers/index.ts +++ b/packages/telescope/src/helpers/index.ts @@ -1,235 +1,3 @@ -export const helpers = `import * as _m0 from "protobufjs/minimal"; -import Long from 'long'; - -// @ts-ignore -if (_m0.util.Long !== Long) { - _m0.util.Long = (Long as any); - - _m0.configure(); -} - -export { Long }; - -declare var self: any | undefined; -declare var window: any | undefined; -declare var global: any | undefined; -var globalThis: any = (() => { - if (typeof globalThis !== 'undefined') return globalThis; - if (typeof self !== 'undefined') return self; - if (typeof window !== 'undefined') return window; - if (typeof global !== 'undefined') return global; - throw 'Unable to locate global object'; -})(); - -const atob: (b64: string) => string = - globalThis.atob || ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary')); - -export function bytesFromBase64(b64: string): Uint8Array { - const bin = atob(b64); - const arr = new Uint8Array(bin.length); - for (let i = 0; i < bin.length; ++i) { - arr[i] = bin.charCodeAt(i); - } - return arr; -} - -const btoa: (bin: string) => string = - globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64')); - -export function base64FromBytes(arr: Uint8Array): string { - const bin: string[] = []; - arr.forEach((byte) => { - bin.push(String.fromCharCode(byte)); - }); - return btoa(bin.join('')); -} - -export interface AminoHeight { - readonly revision_number?: string; - readonly revision_height?: string; -}; - -export function omitDefault(input: T): T | undefined { - if (typeof input === "string") { - return input === "" ? undefined : input; - } - - if (typeof input === "number") { - return input === 0 ? undefined : input; - } - - if (Long.isLong(input)) { - return input.isZero() ? undefined : input; - } - - throw new Error(\`Got unsupported type \${typeof input}\`); -}; - -interface Duration { - /** - * Signed seconds of the span of time. Must be from -315,576,000,000 - * to +315,576,000,000 inclusive. Note: these bounds are computed from: - * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years - */ - seconds: Long; - /** - * Signed fractions of a second at nanosecond resolution of the span - * of time. Durations less than one second are represented with a 0 - * \`seconds\` field and a positive or negative \`nanos\` field. For durations - * of one second or more, a non-zero value for the \`nanos\` field must be - * of the same sign as the \`seconds\` field. Must be from -999,999,999 - * to +999,999,999 inclusive. - */ - - nanos: number; -} - -export function toDuration(duration: string): Duration { - return { - seconds: Long.fromNumber(Math.floor(parseInt(duration) / 1000000000)), - nanos: parseInt(duration) % 1000000000 - }; -}; - -export function fromDuration(duration: Duration): string { - return (parseInt(duration.seconds.toString()) * 1000000000 + duration.nanos).toString(); -}; - -export function isSet(value: any): boolean { - return value !== null && value !== undefined; -}; - -export function isObject(value: any): boolean { - return typeof value === 'object' && value !== null; -}; - -export interface PageRequest { - key: Uint8Array; - offset: Long; - limit: Long; - countTotal: boolean; - reverse: boolean; -}; - -export interface PageRequestParams { - "pagination.key"?: string; - "pagination.offset"?: string; - "pagination.limit"?: string; - "pagination.count_total"?: boolean; - "pagination.reverse"?: boolean; -}; - -export interface Params { - params: PageRequestParams; -}; - -export const setPaginationParams = (options: Params, pagination?: PageRequest) => { - - if (!pagination) { - return options; - } - - if (typeof pagination?.countTotal !== "undefined") { - options.params['pagination.count_total'] = pagination.countTotal; - } - if (typeof pagination?.key !== "undefined") { - // String to Uint8Array - // let uint8arr = new Uint8Array(Buffer.from(data,'base64')); - - // Uint8Array to String - options.params['pagination.key'] = Buffer.from(pagination.key).toString('base64'); - } - if (typeof pagination?.limit !== "undefined") { - options.params["pagination.limit"] = pagination.limit.toString() - } - if (typeof pagination?.offset !== "undefined") { - options.params["pagination.offset"] = pagination.offset.toString() - } - if (typeof pagination?.reverse !== "undefined") { - options.params['pagination.reverse'] = pagination.reverse; - } - - return options; -}; - -type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; - -export type DeepPartial = T extends Builtin - ? T - : T extends Array - ? Array> - : T extends ReadonlyArray - ? ReadonlyArray> - : T extends {} - ? { [K in keyof T]?: DeepPartial } - : Partial; - -type KeysOfUnion = T extends T ? keyof T : never; -export type Exact = P extends Builtin - ? P - : P & { [K in keyof P]: Exact } & Record>, never>; - -export interface Rpc { - request(service: string, method: string, data: Uint8Array): Promise; -}; - -interface Timestamp { - /** - * Represents seconds of UTC time since Unix epoch - * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to - * 9999-12-31T23:59:59Z inclusive. - */ - seconds: Long; - /** - * Non-negative fractions of a second at nanosecond resolution. Negative - * second values with fractions must still have non-negative nanos values - * that count forward in time. Must be from 0 to 999,999,999 - * inclusive. - */ - - nanos: number; -} - -export function toTimestamp(date: Date): Timestamp { - const seconds = numberToLong(date.getTime() / 1_000); - const nanos = date.getTime() % 1000 * 1000000; - return { - seconds, - nanos - }; -}; - -export function fromTimestamp(t: Timestamp): Date { - let millis = t.seconds.toNumber() * 1000; - millis += t.nanos / 1000000; - return new Date(millis); -}; - -const fromJSON = (object: any): Timestamp => { - return { - seconds: isSet(object.seconds) ? Long.fromString(object.seconds) : Long.ZERO, - nanos: isSet(object.nanos) ? Number(object.nanos) : 0 - }; -}; - -const timestampFromJSON = (object: any): Timestamp => { - return { - seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO, - nanos: isSet(object.nanos) ? Number(object.nanos) : 0, - }; -} - -export function fromJsonTimestamp(o: any): Timestamp { - if (o instanceof Date) { - return toTimestamp(o); - } else if (typeof o === "string") { - return toTimestamp(new Date(o)); - } else { - return timestampFromJSON(o); - } -} - -function numberToLong(number: number) { - return Long.fromNumber(number); -} -`; \ No newline at end of file +export * from './external'; +export * from './internal'; +export * from './react-query'; \ No newline at end of file diff --git a/packages/telescope/src/helpers/internal.ts b/packages/telescope/src/helpers/internal.ts new file mode 100644 index 0000000000..10294c71a6 --- /dev/null +++ b/packages/telescope/src/helpers/internal.ts @@ -0,0 +1,235 @@ +export const internal = `import * as _m0 from "protobufjs/minimal"; +import Long from 'long'; + +// @ts-ignore +if (_m0.util.Long !== Long) { + _m0.util.Long = (Long as any); + + _m0.configure(); +} + +export { Long }; + +declare var self: any | undefined; +declare var window: any | undefined; +declare var global: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== 'undefined') return globalThis; + if (typeof self !== 'undefined') return self; + if (typeof window !== 'undefined') return window; + if (typeof global !== 'undefined') return global; + throw 'Unable to locate global object'; +})(); + +const atob: (b64: string) => string = + globalThis.atob || ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary')); + +export function bytesFromBase64(b64: string): Uint8Array { + const bin = atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; +} + +const btoa: (bin: string) => string = + globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64')); + +export function base64FromBytes(arr: Uint8Array): string { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(String.fromCharCode(byte)); + }); + return btoa(bin.join('')); +} + +export interface AminoHeight { + readonly revision_number?: string; + readonly revision_height?: string; +}; + +export function omitDefault(input: T): T | undefined { + if (typeof input === "string") { + return input === "" ? undefined : input; + } + + if (typeof input === "number") { + return input === 0 ? undefined : input; + } + + if (Long.isLong(input)) { + return input.isZero() ? undefined : input; + } + + throw new Error(\`Got unsupported type \${typeof input}\`); +}; + +interface Duration { + /** + * Signed seconds of the span of time. Must be from -315,576,000,000 + * to +315,576,000,000 inclusive. Note: these bounds are computed from: + * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years + */ + seconds: Long; + /** + * Signed fractions of a second at nanosecond resolution of the span + * of time. Durations less than one second are represented with a 0 + * \`seconds\` field and a positive or negative \`nanos\` field. For durations + * of one second or more, a non-zero value for the \`nanos\` field must be + * of the same sign as the \`seconds\` field. Must be from -999,999,999 + * to +999,999,999 inclusive. + */ + + nanos: number; +} + +export function toDuration(duration: string): Duration { + return { + seconds: Long.fromNumber(Math.floor(parseInt(duration) / 1000000000)), + nanos: parseInt(duration) % 1000000000 + }; +}; + +export function fromDuration(duration: Duration): string { + return (parseInt(duration.seconds.toString()) * 1000000000 + duration.nanos).toString(); +}; + +export function isSet(value: any): boolean { + return value !== null && value !== undefined; +}; + +export function isObject(value: any): boolean { + return typeof value === 'object' && value !== null; +}; + +export interface PageRequest { + key: Uint8Array; + offset: Long; + limit: Long; + countTotal: boolean; + reverse: boolean; +}; + +export interface PageRequestParams { + "pagination.key"?: string; + "pagination.offset"?: string; + "pagination.limit"?: string; + "pagination.count_total"?: boolean; + "pagination.reverse"?: boolean; +}; + +export interface Params { + params: PageRequestParams; +}; + +export const setPaginationParams = (options: Params, pagination?: PageRequest) => { + + if (!pagination) { + return options; + } + + if (typeof pagination?.countTotal !== "undefined") { + options.params['pagination.count_total'] = pagination.countTotal; + } + if (typeof pagination?.key !== "undefined") { + // String to Uint8Array + // let uint8arr = new Uint8Array(Buffer.from(data,'base64')); + + // Uint8Array to String + options.params['pagination.key'] = Buffer.from(pagination.key).toString('base64'); + } + if (typeof pagination?.limit !== "undefined") { + options.params["pagination.limit"] = pagination.limit.toString() + } + if (typeof pagination?.offset !== "undefined") { + options.params["pagination.offset"] = pagination.offset.toString() + } + if (typeof pagination?.reverse !== "undefined") { + options.params['pagination.reverse'] = pagination.reverse; + } + + return options; +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +type KeysOfUnion = T extends T ? keyof T : never; +export type Exact = P extends Builtin + ? P + : P & { [K in keyof P]: Exact } & Record>, never>; + +export interface Rpc { + request(service: string, method: string, data: Uint8Array): Promise; +}; + +interface Timestamp { + /** + * Represents seconds of UTC time since Unix epoch + * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to + * 9999-12-31T23:59:59Z inclusive. + */ + seconds: Long; + /** + * Non-negative fractions of a second at nanosecond resolution. Negative + * second values with fractions must still have non-negative nanos values + * that count forward in time. Must be from 0 to 999,999,999 + * inclusive. + */ + + nanos: number; +} + +export function toTimestamp(date: Date): Timestamp { + const seconds = numberToLong(date.getTime() / 1_000); + const nanos = date.getTime() % 1000 * 1000000; + return { + seconds, + nanos + }; +}; + +export function fromTimestamp(t: Timestamp): Date { + let millis = t.seconds.toNumber() * 1000; + millis += t.nanos / 1000000; + return new Date(millis); +}; + +const fromJSON = (object: any): Timestamp => { + return { + seconds: isSet(object.seconds) ? Long.fromString(object.seconds) : Long.ZERO, + nanos: isSet(object.nanos) ? Number(object.nanos) : 0 + }; +}; + +const timestampFromJSON = (object: any): Timestamp => { + return { + seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO, + nanos: isSet(object.nanos) ? Number(object.nanos) : 0, + }; +} + +export function fromJsonTimestamp(o: any): Timestamp { + if (o instanceof Date) { + return toTimestamp(o); + } else if (typeof o === "string") { + return toTimestamp(new Date(o)); + } else { + return timestampFromJSON(o); + } +} + +function numberToLong(number: number) { + return Long.fromNumber(number); +} +`; \ No newline at end of file diff --git a/packages/telescope/src/helpers/react-query.ts b/packages/telescope/src/helpers/react-query.ts new file mode 100644 index 0000000000..2799530772 --- /dev/null +++ b/packages/telescope/src/helpers/react-query.ts @@ -0,0 +1,64 @@ +export const reactQuery = `import { getRpcClient } from './extern' +import { + useQuery, + UseQueryOptions, +} from '@tanstack/react-query'; + +import { HttpEndpoint, ProtobufRpcClient } from '@cosmjs/stargate'; +import { Tendermint34Client } from '@cosmjs/tendermint-rpc'; + +export interface ReactQueryParams { + options?: UseQueryOptions; +} + +export interface UseRpcClientQuery extends ReactQueryParams { + rpcEndpoint: string | HttpEndpoint; +} + +export interface UseRpcEndpointQuery extends ReactQueryParams { + getter: () => Promise; +} + +export const useRpcEndpoint = ({ + getter, + options, +}: UseRpcEndpointQuery) => { + return useQuery(['rpcEndpoint', getter], async () => { + return await getter(); + }, options); +}; + +export const useRpcClient = ({ + rpcEndpoint, + options, +}: UseRpcClientQuery) => { + return useQuery(['rpcClient', rpcEndpoint], async () => { + return await getRpcClient(rpcEndpoint); + }, options); +}; + +interface UseTendermintClient extends ReactQueryParams { + rpcEndpoint: string | HttpEndpoint; +} + +/** + * Hook that uses react-query to cache a connected tendermint client. + */ +export const useTendermintClient = ({ + rpcEndpoint, + options, +}: UseTendermintClient) => { + const { data: client } = useQuery( + ['client', 'tendermint', rpcEndpoint], + () => Tendermint34Client.connect(rpcEndpoint), + { + // allow overriding + onError: (e) => { + throw new Error(\`Failed to connect to \${rpcEndpoint}\` + '\\n' + e) + }, + ...options, + } + ) + return { client } +}; +`; \ No newline at end of file diff --git a/packages/telescope/src/imports.ts b/packages/telescope/src/imports.ts index 9315a9a35b..2afb86f9d6 100644 --- a/packages/telescope/src/imports.ts +++ b/packages/telescope/src/imports.ts @@ -3,7 +3,7 @@ import { GenericParseContext, importStmt } from '@osmonauts/ast'; import { ServiceMutation } from '@osmonauts/types'; import { ImportHash, ImportObj } from './types'; -import { UTILS, getRelativePath } from './utils'; +import { UTILS, getRelativePath, UTIL_HELPERS } from './utils'; import { TelescopeParseContext } from './build'; const importHashToArray = (hash: ImportHash): ImportObj[] => { @@ -123,10 +123,11 @@ export const getImportStatements = ( // swap helpers with helpers file... const modifiedImports = list.map(imp => { - if (imp.path === '__helpers__') { + if (UTIL_HELPERS.includes(imp.path)) { + const name = imp.path.replace(/__/g, ''); return { ...imp, - path: getRelativePath(filepath, './helpers') + path: getRelativePath(filepath, `./${name}`) } } return imp; diff --git a/packages/telescope/src/utils/index.ts b/packages/telescope/src/utils/index.ts index 46e458face..591bb470c1 100644 --- a/packages/telescope/src/utils/index.ts +++ b/packages/telescope/src/utils/index.ts @@ -8,53 +8,70 @@ export const getRoot = (ref: ProtoRef): ProtoRoot => { return ref.proto; }; +// default example: +// Long: { type: 'default', path: 'long', name: 'Long ' }, +// namespaced: +// _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' }, export const UTILS = { + _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' }, AminoHeight: '__helpers__', AminoMsg: '@cosmjs/amino', AminoTypes: '@cosmjs/stargate', + base64FromBytes: '__helpers__', + bytesFromBase64: '__helpers__', + createProtobufRpcClient: '@cosmjs/stargate', decodeBech32Pubkey: '@cosmjs/amino', + DeepPartial: '__helpers__', defaultRegistryTypes: '@cosmjs/stargate', encodeBech32Pubkey: '@cosmjs/amino', + Exact: '__helpers__', fromBase64: '@cosmjs/encoding', fromBech32: '@cosmjs/encoding', fromDuration: '__helpers__', fromHex: '@cosmjs/encoding', - fromUtf8: '@cosmjs/encoding', fromJsonTimestamp: '__helpers__', fromTimestamp: '__helpers__', + fromUtf8: '@cosmjs/encoding', GeneratedType: '@cosmjs/proto-signing', - isSet: '__helpers__', - isObject: '__helpers__', - Long: '__helpers__', // exports Long and also calls the magic Long code - // Long: { type: 'default', path: 'long', name: 'Long ' }, - createProtobufRpcClient: '@cosmjs/stargate', - QueryClient: '@cosmjs/stargate', - Tendermint34Client: '@cosmjs/tendermint-rpc', + getRpcClient: '__extern__', + getRpcEndpointKey: '__extern__', HttpEndpoint: '@cosmjs/tendermint-rpc', + isObject: '__helpers__', + isSet: '__helpers__', + LCDClient: '@osmonauts/lcd', + Long: '__helpers__', OfflineSigner: '@cosmjs/proto-signing', omitDefault: '__helpers__', + ProtobufRpcClient: '@cosmjs/stargate', + QueryClient: '@cosmjs/stargate', Registry: '@cosmjs/proto-signing', + Rpc: '__helpers__', + setPaginationParams: '__helpers__', SigningStargateClient: '@cosmjs/stargate', + Tendermint34Client: '@cosmjs/tendermint-rpc', toBase64: '@cosmjs/encoding', - toUtf8: '@cosmjs/encoding', toDuration: '__helpers__', toTimestamp: '__helpers__', - bytesFromBase64: '__helpers__', - base64FromBytes: '__helpers__', - setPaginationParams: '__helpers__', - _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' }, - Exact: '__helpers__', - Rpc: '__helpers__', - LCDClient: '@osmonauts/lcd', - DeepPartial: '__helpers__' + toUtf8: '@cosmjs/encoding', + useQuery: '@tanstack/react-query', + useRpcEndpoint: '__react-query__', + useRpcClient: '__react-query__', + useTendermintClient: '__react-query__', + ReactQueryParams: '__react-query__', + UseQueryOptions: '@tanstack/react-query', }; +export const UTIL_HELPERS = [ + '__helpers__', + '__extern__', + '__react-query__', +]; export const fixlocalpaths = (imports: ImportObj[]) => { return imports.map(imp => { return { ...imp, - path: (imp.path === '__helpers__' || imp.path.startsWith('.') || imp.path.startsWith('@')) ? + path: (UTIL_HELPERS.includes(imp.path) || imp.path.startsWith('.') || imp.path.startsWith('@')) ? imp.path : `./${imp.path}` }; }) @@ -66,20 +83,4 @@ export const getRelativePath = (f1: string, f2: string) => { let importPath = rel.replace(extname(rel), ''); if (!/^\./.test(importPath)) importPath = `./${importPath}`; return importPath; -} - - -export const variableSlug = (str) => { - str = String(str).toString(); - str = str.replace(/\//g, '_'); - str = str.replace('.', '_'); - str = str.replace(extname(str), ''); - str = str.replace(/^\s+|\s+$/g, ""); // trim - str = str.toLowerCase(); - str = str - .replace(/[^a-z0-9_ -]/g, "") // remove invalid chars - .replace(/\s+/g, "-") // collapse whitespace and replace by - - .replace(/-/g, ""); - - return camel(str); } \ No newline at end of file diff --git a/packages/telescope/types/generators/create-react-query-bundle.d.ts b/packages/telescope/types/generators/create-react-query-bundle.d.ts new file mode 100644 index 0000000000..c436515cae --- /dev/null +++ b/packages/telescope/types/generators/create-react-query-bundle.d.ts @@ -0,0 +1,2 @@ +import { TelescopeBuilder } from '../builder'; +export declare const plugin: (builder: TelescopeBuilder) => void; diff --git a/packages/telescope/types/helpers/external.d.ts b/packages/telescope/types/helpers/external.d.ts new file mode 100644 index 0000000000..441941432d --- /dev/null +++ b/packages/telescope/types/helpers/external.d.ts @@ -0,0 +1 @@ +export declare const external = "import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from '@cosmjs/stargate'\nimport { Tendermint34Client, HttpEndpoint } from \"@cosmjs/tendermint-rpc\";\n\nconst _rpcClients: Record = {};\n\nexport const getRpcEndpointKey = (rpcEndpoint: string | HttpEndpoint) => {\n if (typeof rpcEndpoint === 'string') {\n return rpcEndpoint;\n } else if (!!rpcEndpoint) {\n //@ts-ignore \n return rpcEndpoint.url;\n }\n}\n\nexport const getRpcClient = async (rpcEndpoint: string | HttpEndpoint) => {\n const key = getRpcEndpointKey(rpcEndpoint);\n if (!key) return;\n if (_rpcClients.hasOwnProperty(key)) {\n return _rpcClients[key];\n }\n const tmClient = await Tendermint34Client.connect(rpcEndpoint);\n //@ts-ignore\n const client = new QueryClient(tmClient);\n const rpc = createProtobufRpcClient(client);\n _rpcClients[key] = rpc;\n return rpc;\n}\n"; diff --git a/packages/telescope/types/helpers/index.d.ts b/packages/telescope/types/helpers/index.d.ts index f665360b72..79ae13329b 100644 --- a/packages/telescope/types/helpers/index.d.ts +++ b/packages/telescope/types/helpers/index.d.ts @@ -1 +1,3 @@ -export declare const helpers = "import * as _m0 from \"protobufjs/minimal\";\nimport Long from 'long';\n\n// @ts-ignore\nif (_m0.util.Long !== Long) {\n _m0.util.Long = (Long as any);\n\n _m0.configure();\n}\n\nexport { Long };\n\ndeclare var self: any | undefined;\ndeclare var window: any | undefined;\ndeclare var global: any | undefined;\nvar globalThis: any = (() => {\n if (typeof globalThis !== 'undefined') return globalThis;\n if (typeof self !== 'undefined') return self;\n if (typeof window !== 'undefined') return window;\n if (typeof global !== 'undefined') return global;\n throw 'Unable to locate global object';\n})();\n\nconst atob: (b64: string) => string =\n globalThis.atob || ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));\n\nexport function bytesFromBase64(b64: string): Uint8Array {\n const bin = atob(b64);\n const arr = new Uint8Array(bin.length);\n for (let i = 0; i < bin.length; ++i) {\n arr[i] = bin.charCodeAt(i);\n }\n return arr;\n}\n\nconst btoa: (bin: string) => string =\n globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));\n\nexport function base64FromBytes(arr: Uint8Array): string {\n const bin: string[] = [];\n arr.forEach((byte) => {\n bin.push(String.fromCharCode(byte));\n });\n return btoa(bin.join(''));\n}\n\nexport interface AminoHeight {\n readonly revision_number?: string;\n readonly revision_height?: string;\n};\n\nexport function omitDefault(input: T): T | undefined {\n if (typeof input === \"string\") {\n return input === \"\" ? undefined : input;\n }\n\n if (typeof input === \"number\") {\n return input === 0 ? undefined : input;\n }\n\n if (Long.isLong(input)) {\n return input.isZero() ? undefined : input;\n }\n\n throw new Error(`Got unsupported type ${typeof input}`);\n};\n\ninterface Duration {\n /**\n * Signed seconds of the span of time. Must be from -315,576,000,000\n * to +315,576,000,000 inclusive. Note: these bounds are computed from:\n * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years\n */\n seconds: Long;\n /**\n * Signed fractions of a second at nanosecond resolution of the span\n * of time. Durations less than one second are represented with a 0\n * `seconds` field and a positive or negative `nanos` field. For durations\n * of one second or more, a non-zero value for the `nanos` field must be\n * of the same sign as the `seconds` field. Must be from -999,999,999\n * to +999,999,999 inclusive.\n */\n\n nanos: number;\n}\n\nexport function toDuration(duration: string): Duration {\n return {\n seconds: Long.fromNumber(Math.floor(parseInt(duration) / 1000000000)),\n nanos: parseInt(duration) % 1000000000\n };\n};\n\nexport function fromDuration(duration: Duration): string {\n return (parseInt(duration.seconds.toString()) * 1000000000 + duration.nanos).toString();\n};\n\nexport function isSet(value: any): boolean {\n return value !== null && value !== undefined;\n};\n\nexport function isObject(value: any): boolean {\n return typeof value === 'object' && value !== null;\n};\n\nexport interface PageRequest {\n key: Uint8Array;\n offset: Long;\n limit: Long;\n countTotal: boolean;\n reverse: boolean;\n};\n\nexport interface PageRequestParams {\n \"pagination.key\"?: string;\n \"pagination.offset\"?: string;\n \"pagination.limit\"?: string;\n \"pagination.count_total\"?: boolean;\n \"pagination.reverse\"?: boolean;\n};\n\nexport interface Params {\n params: PageRequestParams;\n};\n\nexport const setPaginationParams = (options: Params, pagination?: PageRequest) => {\n\n if (!pagination) {\n return options;\n }\n\n if (typeof pagination?.countTotal !== \"undefined\") {\n options.params['pagination.count_total'] = pagination.countTotal;\n }\n if (typeof pagination?.key !== \"undefined\") {\n // String to Uint8Array\n // let uint8arr = new Uint8Array(Buffer.from(data,'base64')); \n\n // Uint8Array to String\n options.params['pagination.key'] = Buffer.from(pagination.key).toString('base64');\n }\n if (typeof pagination?.limit !== \"undefined\") {\n options.params[\"pagination.limit\"] = pagination.limit.toString()\n }\n if (typeof pagination?.offset !== \"undefined\") {\n options.params[\"pagination.offset\"] = pagination.offset.toString()\n } \n if (typeof pagination?.reverse !== \"undefined\") {\n options.params['pagination.reverse'] = pagination.reverse;\n }\n\n return options;\n};\n\ntype Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;\n\nexport type DeepPartial = T extends Builtin\n ? T\n : T extends Array\n ? Array>\n : T extends ReadonlyArray\n ? ReadonlyArray>\n : T extends {}\n ? { [K in keyof T]?: DeepPartial }\n : Partial;\n\ntype KeysOfUnion = T extends T ? keyof T : never;\nexport type Exact = P extends Builtin\n ? P\n : P & { [K in keyof P]: Exact } & Record>, never>;\n\nexport interface Rpc {\n request(service: string, method: string, data: Uint8Array): Promise;\n};\n\ninterface Timestamp {\n /**\n * Represents seconds of UTC time since Unix epoch\n * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to\n * 9999-12-31T23:59:59Z inclusive.\n */\n seconds: Long;\n /**\n * Non-negative fractions of a second at nanosecond resolution. Negative\n * second values with fractions must still have non-negative nanos values\n * that count forward in time. Must be from 0 to 999,999,999\n * inclusive.\n */\n\n nanos: number;\n}\n\nexport function toTimestamp(date: Date): Timestamp {\n const seconds = numberToLong(date.getTime() / 1_000);\n const nanos = date.getTime() % 1000 * 1000000;\n return {\n seconds,\n nanos\n };\n};\n\nexport function fromTimestamp(t: Timestamp): Date {\n let millis = t.seconds.toNumber() * 1000;\n millis += t.nanos / 1000000;\n return new Date(millis);\n};\n\nconst fromJSON = (object: any): Timestamp => {\n return {\n seconds: isSet(object.seconds) ? Long.fromString(object.seconds) : Long.ZERO,\n nanos: isSet(object.nanos) ? Number(object.nanos) : 0\n };\n};\n\nconst timestampFromJSON = (object: any): Timestamp => {\n return {\n seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO,\n nanos: isSet(object.nanos) ? Number(object.nanos) : 0,\n };\n}\n \nexport function fromJsonTimestamp(o: any): Timestamp {\n if (o instanceof Date) {\n return toTimestamp(o);\n } else if (typeof o === \"string\") {\n return toTimestamp(new Date(o));\n } else {\n return timestampFromJSON(o);\n }\n}\n \nfunction numberToLong(number: number) {\n return Long.fromNumber(number);\n}\n"; +export * from './external'; +export * from './internal'; +export * from './react-query'; diff --git a/packages/telescope/types/helpers/internal.d.ts b/packages/telescope/types/helpers/internal.d.ts new file mode 100644 index 0000000000..017b1526b6 --- /dev/null +++ b/packages/telescope/types/helpers/internal.d.ts @@ -0,0 +1 @@ +export declare const internal = "import * as _m0 from \"protobufjs/minimal\";\nimport Long from 'long';\n\n// @ts-ignore\nif (_m0.util.Long !== Long) {\n _m0.util.Long = (Long as any);\n\n _m0.configure();\n}\n\nexport { Long };\n\ndeclare var self: any | undefined;\ndeclare var window: any | undefined;\ndeclare var global: any | undefined;\nvar globalThis: any = (() => {\n if (typeof globalThis !== 'undefined') return globalThis;\n if (typeof self !== 'undefined') return self;\n if (typeof window !== 'undefined') return window;\n if (typeof global !== 'undefined') return global;\n throw 'Unable to locate global object';\n})();\n\nconst atob: (b64: string) => string =\n globalThis.atob || ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));\n\nexport function bytesFromBase64(b64: string): Uint8Array {\n const bin = atob(b64);\n const arr = new Uint8Array(bin.length);\n for (let i = 0; i < bin.length; ++i) {\n arr[i] = bin.charCodeAt(i);\n }\n return arr;\n}\n\nconst btoa: (bin: string) => string =\n globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));\n\nexport function base64FromBytes(arr: Uint8Array): string {\n const bin: string[] = [];\n arr.forEach((byte) => {\n bin.push(String.fromCharCode(byte));\n });\n return btoa(bin.join(''));\n}\n\nexport interface AminoHeight {\n readonly revision_number?: string;\n readonly revision_height?: string;\n};\n\nexport function omitDefault(input: T): T | undefined {\n if (typeof input === \"string\") {\n return input === \"\" ? undefined : input;\n }\n\n if (typeof input === \"number\") {\n return input === 0 ? undefined : input;\n }\n\n if (Long.isLong(input)) {\n return input.isZero() ? undefined : input;\n }\n\n throw new Error(`Got unsupported type ${typeof input}`);\n};\n\ninterface Duration {\n /**\n * Signed seconds of the span of time. Must be from -315,576,000,000\n * to +315,576,000,000 inclusive. Note: these bounds are computed from:\n * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years\n */\n seconds: Long;\n /**\n * Signed fractions of a second at nanosecond resolution of the span\n * of time. Durations less than one second are represented with a 0\n * `seconds` field and a positive or negative `nanos` field. For durations\n * of one second or more, a non-zero value for the `nanos` field must be\n * of the same sign as the `seconds` field. Must be from -999,999,999\n * to +999,999,999 inclusive.\n */\n\n nanos: number;\n}\n\nexport function toDuration(duration: string): Duration {\n return {\n seconds: Long.fromNumber(Math.floor(parseInt(duration) / 1000000000)),\n nanos: parseInt(duration) % 1000000000\n };\n};\n\nexport function fromDuration(duration: Duration): string {\n return (parseInt(duration.seconds.toString()) * 1000000000 + duration.nanos).toString();\n};\n\nexport function isSet(value: any): boolean {\n return value !== null && value !== undefined;\n};\n\nexport function isObject(value: any): boolean {\n return typeof value === 'object' && value !== null;\n};\n\nexport interface PageRequest {\n key: Uint8Array;\n offset: Long;\n limit: Long;\n countTotal: boolean;\n reverse: boolean;\n};\n\nexport interface PageRequestParams {\n \"pagination.key\"?: string;\n \"pagination.offset\"?: string;\n \"pagination.limit\"?: string;\n \"pagination.count_total\"?: boolean;\n \"pagination.reverse\"?: boolean;\n};\n\nexport interface Params {\n params: PageRequestParams;\n};\n\nexport const setPaginationParams = (options: Params, pagination?: PageRequest) => {\n\n if (!pagination) {\n return options;\n }\n\n if (typeof pagination?.countTotal !== \"undefined\") {\n options.params['pagination.count_total'] = pagination.countTotal;\n }\n if (typeof pagination?.key !== \"undefined\") {\n // String to Uint8Array\n // let uint8arr = new Uint8Array(Buffer.from(data,'base64')); \n\n // Uint8Array to String\n options.params['pagination.key'] = Buffer.from(pagination.key).toString('base64');\n }\n if (typeof pagination?.limit !== \"undefined\") {\n options.params[\"pagination.limit\"] = pagination.limit.toString()\n }\n if (typeof pagination?.offset !== \"undefined\") {\n options.params[\"pagination.offset\"] = pagination.offset.toString()\n } \n if (typeof pagination?.reverse !== \"undefined\") {\n options.params['pagination.reverse'] = pagination.reverse;\n }\n\n return options;\n};\n\ntype Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;\n\nexport type DeepPartial = T extends Builtin\n ? T\n : T extends Array\n ? Array>\n : T extends ReadonlyArray\n ? ReadonlyArray>\n : T extends {}\n ? { [K in keyof T]?: DeepPartial }\n : Partial;\n\ntype KeysOfUnion = T extends T ? keyof T : never;\nexport type Exact = P extends Builtin\n ? P\n : P & { [K in keyof P]: Exact } & Record>, never>;\n\nexport interface Rpc {\n request(service: string, method: string, data: Uint8Array): Promise;\n};\n\ninterface Timestamp {\n /**\n * Represents seconds of UTC time since Unix epoch\n * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to\n * 9999-12-31T23:59:59Z inclusive.\n */\n seconds: Long;\n /**\n * Non-negative fractions of a second at nanosecond resolution. Negative\n * second values with fractions must still have non-negative nanos values\n * that count forward in time. Must be from 0 to 999,999,999\n * inclusive.\n */\n\n nanos: number;\n}\n\nexport function toTimestamp(date: Date): Timestamp {\n const seconds = numberToLong(date.getTime() / 1_000);\n const nanos = date.getTime() % 1000 * 1000000;\n return {\n seconds,\n nanos\n };\n};\n\nexport function fromTimestamp(t: Timestamp): Date {\n let millis = t.seconds.toNumber() * 1000;\n millis += t.nanos / 1000000;\n return new Date(millis);\n};\n\nconst fromJSON = (object: any): Timestamp => {\n return {\n seconds: isSet(object.seconds) ? Long.fromString(object.seconds) : Long.ZERO,\n nanos: isSet(object.nanos) ? Number(object.nanos) : 0\n };\n};\n\nconst timestampFromJSON = (object: any): Timestamp => {\n return {\n seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO,\n nanos: isSet(object.nanos) ? Number(object.nanos) : 0,\n };\n}\n \nexport function fromJsonTimestamp(o: any): Timestamp {\n if (o instanceof Date) {\n return toTimestamp(o);\n } else if (typeof o === \"string\") {\n return toTimestamp(new Date(o));\n } else {\n return timestampFromJSON(o);\n }\n}\n \nfunction numberToLong(number: number) {\n return Long.fromNumber(number);\n}\n"; diff --git a/packages/telescope/types/helpers/react-query.d.ts b/packages/telescope/types/helpers/react-query.d.ts new file mode 100644 index 0000000000..1336abeece --- /dev/null +++ b/packages/telescope/types/helpers/react-query.d.ts @@ -0,0 +1 @@ +export declare const reactQuery = "import { getRpcClient } from './extern'\nimport {\n useQuery,\n UseQueryOptions,\n} from '@tanstack/react-query';\n\nimport { HttpEndpoint, ProtobufRpcClient } from '@cosmjs/stargate';\nimport { Tendermint34Client } from '@cosmjs/tendermint-rpc';\n\nexport interface ReactQueryParams {\n options?: UseQueryOptions;\n}\n\nexport interface UseRpcClientQuery extends ReactQueryParams {\n rpcEndpoint: string | HttpEndpoint;\n}\n\nexport interface UseRpcEndpointQuery extends ReactQueryParams {\n getter: () => Promise;\n}\n\nexport const useRpcEndpoint = ({\n getter,\n options,\n}: UseRpcEndpointQuery) => {\n return useQuery(['rpcEndpoint', getter], async () => {\n return await getter();\n }, options);\n};\n\nexport const useRpcClient = ({\n rpcEndpoint,\n options,\n}: UseRpcClientQuery) => {\n return useQuery(['rpcClient', rpcEndpoint], async () => {\n return await getRpcClient(rpcEndpoint);\n }, options);\n};\n\ninterface UseTendermintClient extends ReactQueryParams {\n rpcEndpoint: string | HttpEndpoint;\n}\n\n/**\n * Hook that uses react-query to cache a connected tendermint client.\n */\nexport const useTendermintClient = ({\n rpcEndpoint,\n options,\n}: UseTendermintClient) => {\n const { data: client } = useQuery(\n ['client', 'tendermint', rpcEndpoint],\n () => Tendermint34Client.connect(rpcEndpoint),\n {\n // allow overriding\n onError: (e) => {\n throw new Error(`Failed to connect to ${rpcEndpoint}` + '\\n' + e)\n },\n ...options,\n }\n )\n return { client }\n};\n"; diff --git a/packages/telescope/types/utils/index.d.ts b/packages/telescope/types/utils/index.d.ts index baa1ed3a0f..79865835d1 100644 --- a/packages/telescope/types/utils/index.d.ts +++ b/packages/telescope/types/utils/index.d.ts @@ -2,48 +2,58 @@ import { ProtoRoot, ProtoRef } from '@osmonauts/types'; import { ImportObj } from '../types'; export declare const getRoot: (ref: ProtoRef) => ProtoRoot; export declare const UTILS: { + _m0: { + type: string; + path: string; + name: string; + }; AminoHeight: string; AminoMsg: string; AminoTypes: string; + base64FromBytes: string; + bytesFromBase64: string; + createProtobufRpcClient: string; decodeBech32Pubkey: string; + DeepPartial: string; defaultRegistryTypes: string; encodeBech32Pubkey: string; + Exact: string; fromBase64: string; fromBech32: string; fromDuration: string; fromHex: string; - fromUtf8: string; fromJsonTimestamp: string; fromTimestamp: string; + fromUtf8: string; GeneratedType: string; - isSet: string; + getRpcClient: string; + getRpcEndpointKey: string; + HttpEndpoint: string; isObject: string; + isSet: string; + LCDClient: string; Long: string; - createProtobufRpcClient: string; - QueryClient: string; - Tendermint34Client: string; - HttpEndpoint: string; OfflineSigner: string; omitDefault: string; + ProtobufRpcClient: string; + QueryClient: string; Registry: string; + Rpc: string; + setPaginationParams: string; SigningStargateClient: string; + Tendermint34Client: string; toBase64: string; - toUtf8: string; toDuration: string; toTimestamp: string; - bytesFromBase64: string; - base64FromBytes: string; - setPaginationParams: string; - _m0: { - type: string; - path: string; - name: string; - }; - Exact: string; - Rpc: string; - LCDClient: string; - DeepPartial: string; + toUtf8: string; + useQuery: string; + useRpcEndpoint: string; + useRpcClient: string; + useTendermintClient: string; + ReactQueryParams: string; + UseQueryOptions: string; }; +export declare const UTIL_HELPERS: string[]; export declare const fixlocalpaths: (imports: ImportObj[]) => { path: string; type: string; @@ -51,4 +61,3 @@ export declare const fixlocalpaths: (imports: ImportObj[]) => { importAs?: string; }[]; export declare const getRelativePath: (f1: string, f2: string) => string; -export declare const variableSlug: (str: any) => any; diff --git a/packages/test/package.json b/packages/test/package.json index 210909ca79..98badeac78 100644 --- a/packages/test/package.json +++ b/packages/test/package.json @@ -89,6 +89,7 @@ "@cosmjs/stargate": "0.29.3", "@cosmjs/tendermint-rpc": "^0.29.3", "@osmonauts/lcd": "^0.8.0", + "@tanstack/react-query": "4.16.1", "long": "^5.2.0", "protobufjs": "^6.11.3" } diff --git a/packages/test/scripts/codegen.js b/packages/test/scripts/codegen.js index 264b05e30d..0c53555417 100644 --- a/packages/test/scripts/codegen.js +++ b/packages/test/scripts/codegen.js @@ -13,9 +13,7 @@ telescope({ removeUnusedImports: true, prototypes: { excluded: { - packages: [ - 'cosmos.group.v1' - ] + packages: ['cosmos.group.v1'] }, methods: { fromJSON: false, @@ -40,15 +38,20 @@ telescope({ enabled: true, camelCase: true }, + reactQuery: { + enabled: true + }, packages: { osmosis: { classesUseArrowFunctions: true } } } -}).then(()=>{ - console.log('✨ all done!'); -}).catch(e=>{ - console.error(e); - process.exit(1); -}); +}) + .then(() => { + console.log('✨ all done!'); + }) + .catch((e) => { + console.error(e); + process.exit(1); + }); diff --git a/packages/types/src/telescope.ts b/packages/types/src/telescope.ts index 2b3fece46e..2b4387635c 100644 --- a/packages/types/src/telescope.ts +++ b/packages/types/src/telescope.ts @@ -104,7 +104,6 @@ interface TelescopeOpts { methodName?: string; }[]; }; - rpcClients?: { enabled: boolean; inline?: boolean; @@ -129,6 +128,9 @@ interface TelescopeOpts { methodNameTx?: string; }[]; }; + reactQuery?: { + enabled: boolean; + }; } interface TelescopePackageOpts { packages?: Record; @@ -227,6 +229,10 @@ export const defaultTelescopeOptions: TelescopeOptions = { scopedIsExclusive: true }, + reactQuery: { + enabled: false + }, + // packages packages: { cosmos: { diff --git a/packages/types/types/telescope.d.ts b/packages/types/types/telescope.d.ts index aa82fe1b3a..8bedfab058 100644 --- a/packages/types/types/telescope.d.ts +++ b/packages/types/types/telescope.d.ts @@ -105,6 +105,9 @@ interface TelescopeOpts { methodNameTx?: string; }[]; }; + reactQuery?: { + enabled: boolean; + }; } interface TelescopePackageOpts { packages?: Record; diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts index c6f727288c..b7fdc47d1d 100644 --- a/packages/utils/src/index.ts +++ b/packages/utils/src/index.ts @@ -1 +1,2 @@ -export * from './case'; \ No newline at end of file +export * from './case'; +export * from './slugs'; \ No newline at end of file diff --git a/packages/utils/src/slugs.ts b/packages/utils/src/slugs.ts new file mode 100644 index 0000000000..e24c97e39c --- /dev/null +++ b/packages/utils/src/slugs.ts @@ -0,0 +1,17 @@ +import { camel } from '@osmonauts/utils'; +import { relative, dirname, extname } from 'path'; + +export const variableSlug = (str) => { + str = String(str).toString(); + str = str.replace(/\//g, '_'); + str = str.replace('.', '_'); + str = str.replace(extname(str), ''); + str = str.replace(/^\s+|\s+$/g, ""); // trim + str = str.toLowerCase(); + str = str + .replace(/[^a-z0-9_ -]/g, "") // remove invalid chars + .replace(/\s+/g, "-") // collapse whitespace and replace by - + .replace(/-/g, ""); + + return camel(str); +} \ No newline at end of file diff --git a/packages/utils/types/index.d.ts b/packages/utils/types/index.d.ts index 16cf1cf67f..688fbd796d 100644 --- a/packages/utils/types/index.d.ts +++ b/packages/utils/types/index.d.ts @@ -1 +1,2 @@ export * from './case'; +export * from './slugs'; diff --git a/packages/utils/types/slugs.d.ts b/packages/utils/types/slugs.d.ts new file mode 100644 index 0000000000..e61b73d43e --- /dev/null +++ b/packages/utils/types/slugs.d.ts @@ -0,0 +1 @@ +export declare const variableSlug: (str: any) => any; diff --git a/yarn.lock b/yarn.lock index de8ebf28ac..2ce673f89a 100644 --- a/yarn.lock +++ b/yarn.lock @@ -3182,6 +3182,19 @@ dependencies: "@sinonjs/commons" "^1.7.0" +"@tanstack/query-core@4.15.1": + version "4.15.1" + resolved "https://registry.npmjs.org/@tanstack/query-core/-/query-core-4.15.1.tgz#a282f04fe5e612b50019e1cfaf0efabd220e00ce" + integrity sha512-+UfqJsNbPIVo0a9ANW0ZxtjiMfGLaaoIaL9vZeVycvmBuWywJGtSi7fgPVMCPdZQFOzMsaXaOsDtSKQD5xLRVQ== + +"@tanstack/react-query@4.16.1": + version "4.16.1" + resolved "https://registry.npmjs.org/@tanstack/react-query/-/react-query-4.16.1.tgz#077006b8eb2c87fbe8d1597c1a0083a2d218b791" + integrity sha512-PDE9u49wSDykPazlCoLFevUpceLjQ0Mm8i6038HgtTEKb/aoVnUZdlUP7C392ds3Cd75+EGlHU7qpEX06R7d9Q== + dependencies: + "@tanstack/query-core" "4.15.1" + use-sync-external-store "^1.2.0" + "@tootallnate/once@1": version "1.1.2" resolved "https://registry.npmjs.org/@tootallnate/once/-/once-1.1.2.tgz#ccb91445360179a04e7fe6aff78c00ffc1eeaf82" @@ -8938,6 +8951,11 @@ uri-js@^4.2.2: dependencies: punycode "^2.1.0" +use-sync-external-store@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.2.0.tgz#7dbefd6ef3fe4e767a0cf5d7287aacfb5846928a" + integrity sha512-eEgnFxGQ1Ife9bzYs6VLi8/4X6CObHMw9Qr9tPY43iKwsPw8xE8+EFsf/2cFZ5S3esXgpWgtSCtLNS41F+sKPA== + util-deprecate@^1.0.1, util-deprecate@~1.0.1: version "1.0.2" resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"