@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/cosmos/nft/v1beta1/nft.ts

@@ -0,0 +1,389 @@
+//@ts-nocheck
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** Class defines the class of the nft type. */
+export interface Class {
+  /** id defines the unique identifier of the NFT classification, similar to the contract address of ERC721 */
+  id: string;
+  /** name defines the human-readable name of the NFT classification. Optional */
+  name: string;
+  /** symbol is an abbreviated name for nft classification. Optional */
+  symbol: string;
+  /** description is a brief description of nft classification. Optional */
+  description: string;
+  /** uri for the class metadata stored off chain. It can define schema for Class and NFT `Data` attributes. Optional */
+  uri: string;
+  /** uri_hash is a hash of the document pointed by uri. Optional */
+  uriHash: string;
+  /** data is the app specific metadata of the NFT class. Optional */
+  data?: Any;
+}
+export interface ClassProtoMsg {
+  typeUrl: "/cosmos.nft.v1beta1.Class";
+  value: Uint8Array;
+}
+/**
+ * Class defines the class of the nft type.
+ * @name ClassAmino
+ * @package cosmos.nft.v1beta1
+ * @see proto type: cosmos.nft.v1beta1.Class
+ */
+export interface ClassAmino {
+  /**
+   * id defines the unique identifier of the NFT classification, similar to the contract address of ERC721
+   */
+  id?: string;
+  /**
+   * name defines the human-readable name of the NFT classification. Optional
+   */
+  name?: string;
+  /**
+   * symbol is an abbreviated name for nft classification. Optional
+   */
+  symbol?: string;
+  /**
+   * description is a brief description of nft classification. Optional
+   */
+  description?: string;
+  /**
+   * uri for the class metadata stored off chain. It can define schema for Class and NFT `Data` attributes. Optional
+   */
+  uri?: string;
+  /**
+   * uri_hash is a hash of the document pointed by uri. Optional
+   */
+  uri_hash?: string;
+  /**
+   * data is the app specific metadata of the NFT class. Optional
+   */
+  data?: AnyAmino;
+}
+export interface ClassAminoMsg {
+  type: "cosmos-sdk/Class";
+  value: ClassAmino;
+}
+/** Class defines the class of the nft type. */
+export interface ClassSDKType {
+  id: string;
+  name: string;
+  symbol: string;
+  description: string;
+  uri: string;
+  uri_hash: string;
+  data?: AnySDKType;
+}
+/** NFT defines the NFT. */
+export interface NFT {
+  /** class_id associated with the NFT, similar to the contract address of ERC721 */
+  classId: string;
+  /** id is a unique identifier of the NFT */
+  id: string;
+  /** uri for the NFT metadata stored off chain */
+  uri: string;
+  /** uri_hash is a hash of the document pointed by uri */
+  uriHash: string;
+  /** data is an app specific data of the NFT. Optional */
+  data?: Any;
+}
+export interface NFTProtoMsg {
+  typeUrl: "/cosmos.nft.v1beta1.NFT";
+  value: Uint8Array;
+}
+/**
+ * NFT defines the NFT.
+ * @name NFTAmino
+ * @package cosmos.nft.v1beta1
+ * @see proto type: cosmos.nft.v1beta1.NFT
+ */
+export interface NFTAmino {
+  /**
+   * class_id associated with the NFT, similar to the contract address of ERC721
+   */
+  class_id?: string;
+  /**
+   * id is a unique identifier of the NFT
+   */
+  id?: string;
+  /**
+   * uri for the NFT metadata stored off chain
+   */
+  uri?: string;
+  /**
+   * uri_hash is a hash of the document pointed by uri
+   */
+  uri_hash?: string;
+  /**
+   * data is an app specific data of the NFT. Optional
+   */
+  data?: AnyAmino;
+}
+export interface NFTAminoMsg {
+  type: "cosmos-sdk/NFT";
+  value: NFTAmino;
+}
+/** NFT defines the NFT. */
+export interface NFTSDKType {
+  class_id: string;
+  id: string;
+  uri: string;
+  uri_hash: string;
+  data?: AnySDKType;
+}
+function createBaseClass(): Class {
+  return {
+    id: "",
+    name: "",
+    symbol: "",
+    description: "",
+    uri: "",
+    uriHash: "",
+    data: undefined
+  };
+}
+export const Class = {
+  typeUrl: "/cosmos.nft.v1beta1.Class",
+  encode(message: Class, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.symbol !== "") {
+      writer.uint32(26).string(message.symbol);
+    }
+    if (message.description !== "") {
+      writer.uint32(34).string(message.description);
+    }
+    if (message.uri !== "") {
+      writer.uint32(42).string(message.uri);
+    }
+    if (message.uriHash !== "") {
+      writer.uint32(50).string(message.uriHash);
+    }
+    if (message.data !== undefined) {
+      Any.encode(message.data, writer.uint32(58).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Class {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClass();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        case 3:
+          message.symbol = reader.string();
+          break;
+        case 4:
+          message.description = reader.string();
+          break;
+        case 5:
+          message.uri = reader.string();
+          break;
+        case 6:
+          message.uriHash = reader.string();
+          break;
+        case 7:
+          message.data = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Class>): Class {
+    const message = createBaseClass();
+    message.id = object.id ?? "";
+    message.name = object.name ?? "";
+    message.symbol = object.symbol ?? "";
+    message.description = object.description ?? "";
+    message.uri = object.uri ?? "";
+    message.uriHash = object.uriHash ?? "";
+    message.data = object.data !== undefined && object.data !== null ? Any.fromPartial(object.data) : undefined;
+    return message;
+  },
+  fromAmino(object: ClassAmino): Class {
+    const message = createBaseClass();
+    if (object.id !== undefined && object.id !== null) {
+      message.id = object.id;
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.symbol !== undefined && object.symbol !== null) {
+      message.symbol = object.symbol;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    if (object.uri !== undefined && object.uri !== null) {
+      message.uri = object.uri;
+    }
+    if (object.uri_hash !== undefined && object.uri_hash !== null) {
+      message.uriHash = object.uri_hash;
+    }
+    if (object.data !== undefined && object.data !== null) {
+      message.data = Any.fromAmino(object.data);
+    }
+    return message;
+  },
+  toAmino(message: Class): ClassAmino {
+    const obj: any = {};
+    obj.id = message.id === "" ? undefined : message.id;
+    obj.name = message.name === "" ? undefined : message.name;
+    obj.symbol = message.symbol === "" ? undefined : message.symbol;
+    obj.description = message.description === "" ? undefined : message.description;
+    obj.uri = message.uri === "" ? undefined : message.uri;
+    obj.uri_hash = message.uriHash === "" ? undefined : message.uriHash;
+    obj.data = message.data ? Any.toAmino(message.data) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ClassAminoMsg): Class {
+    return Class.fromAmino(object.value);
+  },
+  toAminoMsg(message: Class): ClassAminoMsg {
+    return {
+      type: "cosmos-sdk/Class",
+      value: Class.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ClassProtoMsg): Class {
+    return Class.decode(message.value);
+  },
+  toProto(message: Class): Uint8Array {
+    return Class.encode(message).finish();
+  },
+  toProtoMsg(message: Class): ClassProtoMsg {
+    return {
+      typeUrl: "/cosmos.nft.v1beta1.Class",
+      value: Class.encode(message).finish()
+    };
+  }
+};
+function createBaseNFT(): NFT {
+  return {
+    classId: "",
+    id: "",
+    uri: "",
+    uriHash: "",
+    data: undefined
+  };
+}
+export const NFT = {
+  typeUrl: "/cosmos.nft.v1beta1.NFT",
+  encode(message: NFT, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.classId !== "") {
+      writer.uint32(10).string(message.classId);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    if (message.uri !== "") {
+      writer.uint32(26).string(message.uri);
+    }
+    if (message.uriHash !== "") {
+      writer.uint32(34).string(message.uriHash);
+    }
+    if (message.data !== undefined) {
+      Any.encode(message.data, writer.uint32(82).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): NFT {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseNFT();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.classId = reader.string();
+          break;
+        case 2:
+          message.id = reader.string();
+          break;
+        case 3:
+          message.uri = reader.string();
+          break;
+        case 4:
+          message.uriHash = reader.string();
+          break;
+        case 10:
+          message.data = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<NFT>): NFT {
+    const message = createBaseNFT();
+    message.classId = object.classId ?? "";
+    message.id = object.id ?? "";
+    message.uri = object.uri ?? "";
+    message.uriHash = object.uriHash ?? "";
+    message.data = object.data !== undefined && object.data !== null ? Any.fromPartial(object.data) : undefined;
+    return message;
+  },
+  fromAmino(object: NFTAmino): NFT {
+    const message = createBaseNFT();
+    if (object.class_id !== undefined && object.class_id !== null) {
+      message.classId = object.class_id;
+    }
+    if (object.id !== undefined && object.id !== null) {
+      message.id = object.id;
+    }
+    if (object.uri !== undefined && object.uri !== null) {
+      message.uri = object.uri;
+    }
+    if (object.uri_hash !== undefined && object.uri_hash !== null) {
+      message.uriHash = object.uri_hash;
+    }
+    if (object.data !== undefined && object.data !== null) {
+      message.data = Any.fromAmino(object.data);
+    }
+    return message;
+  },
+  toAmino(message: NFT): NFTAmino {
+    const obj: any = {};
+    obj.class_id = message.classId === "" ? undefined : message.classId;
+    obj.id = message.id === "" ? undefined : message.id;
+    obj.uri = message.uri === "" ? undefined : message.uri;
+    obj.uri_hash = message.uriHash === "" ? undefined : message.uriHash;
+    obj.data = message.data ? Any.toAmino(message.data) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: NFTAminoMsg): NFT {
+    return NFT.fromAmino(object.value);
+  },
+  toAminoMsg(message: NFT): NFTAminoMsg {
+    return {
+      type: "cosmos-sdk/NFT",
+      value: NFT.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: NFTProtoMsg): NFT {
+    return NFT.decode(message.value);
+  },
+  toProto(message: NFT): Uint8Array {
+    return NFT.encode(message).finish();
+  },
+  toProtoMsg(message: NFT): NFTProtoMsg {
+    return {
+      typeUrl: "/cosmos.nft.v1beta1.NFT",
+      value: NFT.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/nft/v1beta1/query.lcd.ts

@@ -0,0 +1,77 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/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/types/cosmos/nft/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,102 @@
+//@ts-nocheck
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+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 BinaryReader(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 BinaryReader(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 BinaryReader(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 BinaryReader(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 BinaryReader(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 BinaryReader(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 BinaryReader(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);
+    }
+  };
+};