//@ts-nocheck
import { Rpc } from "../../../helpers";
import { BinaryReader } from "../../../binary";
import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate";
import { ReactQueryParams } from "../../../react-query";
import { useQuery } from "@tanstack/react-query";
import { QueryParamsRequest, QueryParamsResponse, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse } from "./query";
/** Query defines the gRPC querier service. */
export interface Query {
/**
* Params defines a gRPC query method that returns the tokenfactory module's
* parameters.
*/
params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
/**
* DenomAuthorityMetadata defines a gRPC query method for fetching
* DenomAuthorityMetadata for a particular denom.
*/
denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse>;
/**
* DenomsFromCreator defines a gRPC query method for fetching all
* denominations created by a specific admin/creator.
*/
denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse>;
}
export class QueryClientImpl implements Query {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
this.params = this.params.bind(this);
this.denomAuthorityMetadata = this.denomAuthorityMetadata.bind(this);
this.denomsFromCreator = this.denomsFromCreator.bind(this);
}
params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
const data = QueryParamsRequest.encode(request).finish();
const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Query", "Params", data);
return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
}
denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse> {
const data = QueryDenomAuthorityMetadataRequest.encode(request).finish();
const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Query", "DenomAuthorityMetadata", data);
return promise.then(data => QueryDenomAuthorityMetadataResponse.decode(new BinaryReader(data)));
}
denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse> {
const data = QueryDenomsFromCreatorRequest.encode(request).finish();
const promise = this.rpc.request("osmosis.tokenfactory.v1beta1.Query", "DenomsFromCreator", data);
return promise.then(data => QueryDenomsFromCreatorResponse.decode(new BinaryReader(data)));
}
}
export const createRpcQueryExtension = (base: QueryClient) => {
const rpc = createProtobufRpcClient(base);
const queryService = new QueryClientImpl(rpc);
return {
params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
return queryService.params(request);
},
denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse> {
return queryService.denomAuthorityMetadata(request);
},
denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse> {
return queryService.denomsFromCreator(request);
}
};
};
export interface UseParamsQuery<TData> extends ReactQueryParams<QueryParamsResponse, TData> {
request?: QueryParamsRequest;
}
export interface UseDenomAuthorityMetadataQuery<TData> extends ReactQueryParams<QueryDenomAuthorityMetadataResponse, TData> {
request: QueryDenomAuthorityMetadataRequest;
}
export interface UseDenomsFromCreatorQuery<TData> extends ReactQueryParams<QueryDenomsFromCreatorResponse, TData> {
request: QueryDenomsFromCreatorRequest;
}
const _queryClients: WeakMap<ProtobufRpcClient, QueryClientImpl> = 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 = <TData = QueryParamsResponse,>({
request,
options
}: UseParamsQuery<TData>) => {
return useQuery<QueryParamsResponse, Error, TData>(["paramsQuery", request], () => {
if (!queryService) throw new Error("Query Service not initialized");
return queryService.params(request);
}, options);
};
const useDenomAuthorityMetadata = <TData = QueryDenomAuthorityMetadataResponse,>({
request,
options
}: UseDenomAuthorityMetadataQuery<TData>) => {
return useQuery<QueryDenomAuthorityMetadataResponse, Error, TData>(["denomAuthorityMetadataQuery", request], () => {
if (!queryService) throw new Error("Query Service not initialized");
return queryService.denomAuthorityMetadata(request);
}, options);
};
const useDenomsFromCreator = <TData = QueryDenomsFromCreatorResponse,>({
request,
options
}: UseDenomsFromCreatorQuery<TData>) => {
return useQuery<QueryDenomsFromCreatorResponse, Error, TData>(["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
};
};