@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/nft/v1beta1/query.lcd.ts

@@ -0,0 +1,98 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryBalanceRequest, QueryBalanceResponseSDKType, QueryOwnerRequest, QueryOwnerResponseSDKType, QuerySupplyRequest, QuerySupplyResponseSDKType, QueryNFTsRequest, QueryNFTsResponseSDKType, QueryNFTRequest, QueryNFTResponseSDKType, QueryClassRequest, QueryClassResponseSDKType, QueryClassesRequest, QueryClassesResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.balance = this.balance.bind(this);
+    this.owner = this.owner.bind(this);
+    this.supply = this.supply.bind(this);
+    this.nFTs = this.nFTs.bind(this);
+    this.nFT = this.nFT.bind(this);
+    this.class = this.class.bind(this);
+    this.classes = this.classes.bind(this);
+  }
+  /* Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 */
+
+
+  async balance(params: QueryBalanceRequest): Promise<QueryBalanceResponseSDKType> {
+    const endpoint = `cosmos/nft/v1beta1/balance/${params.owner}/${params.classId}`;
+    return await this.req.get<QueryBalanceResponseSDKType>(endpoint);
+  }
+  /* Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 */
+
+
+  async owner(params: QueryOwnerRequest): Promise<QueryOwnerResponseSDKType> {
+    const endpoint = `cosmos/nft/v1beta1/owner/${params.classId}/${params.id}`;
+    return await this.req.get<QueryOwnerResponseSDKType>(endpoint);
+  }
+  /* Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. */
+
+
+  async supply(params: QuerySupplyRequest): Promise<QuerySupplyResponseSDKType> {
+    const endpoint = `cosmos/nft/v1beta1/supply/${params.classId}`;
+    return await this.req.get<QuerySupplyResponseSDKType>(endpoint);
+  }
+  /* NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in
+   ERC721Enumerable */
+
+
+  async nFTs(params: QueryNFTsRequest): Promise<QueryNFTsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.classId !== "undefined") {
+      options.params.class_id = params.classId;
+    }
+
+    if (typeof params?.owner !== "undefined") {
+      options.params.owner = params.owner;
+    }
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/nft/v1beta1/nfts`;
+    return await this.req.get<QueryNFTsResponseSDKType>(endpoint, options);
+  }
+  /* NFT queries an NFT based on its class and id. */
+
+
+  async nFT(params: QueryNFTRequest): Promise<QueryNFTResponseSDKType> {
+    const endpoint = `cosmos/nft/v1beta1/nfts/${params.classId}/${params.id}`;
+    return await this.req.get<QueryNFTResponseSDKType>(endpoint);
+  }
+  /* Class queries an NFT class based on its id */
+
+
+  async class(params: QueryClassRequest): Promise<QueryClassResponseSDKType> {
+    const endpoint = `cosmos/nft/v1beta1/classes/${params.classId}`;
+    return await this.req.get<QueryClassResponseSDKType>(endpoint);
+  }
+  /* Classes queries all NFT classes */
+
+
+  async classes(params: QueryClassesRequest = {
+    pagination: undefined
+  }): Promise<QueryClassesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `cosmos/nft/v1beta1/classes`;
+    return await this.req.get<QueryClassesResponseSDKType>(endpoint, options);
+  }
+
+}

package/src/codegen/cosmos/nft/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,124 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryBalanceRequest, QueryBalanceResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryNFTsRequest, QueryNFTsResponse, QueryNFTRequest, QueryNFTResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 */
+  balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+  /** Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 */
+
+  owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse>;
+  /** Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. */
+
+  supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse>;
+  /**
+   * NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in
+   * ERC721Enumerable
+   */
+
+  nFTs(request: QueryNFTsRequest): Promise<QueryNFTsResponse>;
+  /** NFT queries an NFT based on its class and id. */
+
+  nFT(request: QueryNFTRequest): Promise<QueryNFTResponse>;
+  /** Class queries an NFT class based on its id */
+
+  class(request: QueryClassRequest): Promise<QueryClassResponse>;
+  /** Classes queries all NFT classes */
+
+  classes(request?: QueryClassesRequest): Promise<QueryClassesResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.balance = this.balance.bind(this);
+    this.owner = this.owner.bind(this);
+    this.supply = this.supply.bind(this);
+    this.nFTs = this.nFTs.bind(this);
+    this.nFT = this.nFT.bind(this);
+    this.class = this.class.bind(this);
+    this.classes = this.classes.bind(this);
+  }
+
+  balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+    const data = QueryBalanceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Balance", data);
+    return promise.then(data => QueryBalanceResponse.decode(new _m0.Reader(data)));
+  }
+
+  owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse> {
+    const data = QueryOwnerRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Owner", data);
+    return promise.then(data => QueryOwnerResponse.decode(new _m0.Reader(data)));
+  }
+
+  supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse> {
+    const data = QuerySupplyRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Supply", data);
+    return promise.then(data => QuerySupplyResponse.decode(new _m0.Reader(data)));
+  }
+
+  nFTs(request: QueryNFTsRequest): Promise<QueryNFTsResponse> {
+    const data = QueryNFTsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "NFTs", data);
+    return promise.then(data => QueryNFTsResponse.decode(new _m0.Reader(data)));
+  }
+
+  nFT(request: QueryNFTRequest): Promise<QueryNFTResponse> {
+    const data = QueryNFTRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "NFT", data);
+    return promise.then(data => QueryNFTResponse.decode(new _m0.Reader(data)));
+  }
+
+  class(request: QueryClassRequest): Promise<QueryClassResponse> {
+    const data = QueryClassRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Class", data);
+    return promise.then(data => QueryClassResponse.decode(new _m0.Reader(data)));
+  }
+
+  classes(request: QueryClassesRequest = {
+    pagination: undefined
+  }): Promise<QueryClassesResponse> {
+    const data = QueryClassesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Classes", data);
+    return promise.then(data => QueryClassesResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+      return queryService.balance(request);
+    },
+
+    owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse> {
+      return queryService.owner(request);
+    },
+
+    supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse> {
+      return queryService.supply(request);
+    },
+
+    nFTs(request: QueryNFTsRequest): Promise<QueryNFTsResponse> {
+      return queryService.nFTs(request);
+    },
+
+    nFT(request: QueryNFTRequest): Promise<QueryNFTResponse> {
+      return queryService.nFT(request);
+    },
+
+    class(request: QueryClassRequest): Promise<QueryClassResponse> {
+      return queryService.class(request);
+    },
+
+    classes(request?: QueryClassesRequest): Promise<QueryClassesResponse> {
+      return queryService.classes(request);
+    }
+
+  };
+};