@iconlake/client 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iconlake/client",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "iconLake Typescript Client",
   "author": "iconLake",
   "license": "Apache-2.0",

package/types/iconlake.drop/module.d.ts

@@ -3,25 +3,25 @@ import { DeliverTxResponse } from "@cosmjs/stargate";
 import { EncodeObject, GeneratedType, OfflineSigner, Registry } from "@cosmjs/proto-signing";
 import { IgniteClient } from "../client";
 import { Api } from "./rest";
-import { MsgInit } from "./types/iconlake/drop/tx";
 import { MsgMint } from "./types/iconlake/drop/tx";
-export { MsgInit, MsgMint };
-type sendMsgInitParams = {
-    value: MsgInit;
-    fee?: StdFee;
-    memo?: string;
-};
+import { MsgInit } from "./types/iconlake/drop/tx";
+export { MsgMint, MsgInit };
 type sendMsgMintParams = {
     value: MsgMint;
     fee?: StdFee;
     memo?: string;
 };
-type msgInitParams = {
+type sendMsgInitParams = {
     value: MsgInit;
+    fee?: StdFee;
+    memo?: string;
 };
 type msgMintParams = {
     value: MsgMint;
 };
+type msgInitParams = {
+    value: MsgInit;
+};
 export declare const registry: Registry;
 interface TxClientOptions {
     addr: string;
@@ -29,10 +29,10 @@ interface TxClientOptions {
     signer?: OfflineSigner;
 }
 export declare const txClient: ({ signer, prefix, addr }?: TxClientOptions) => {
-    sendMsgInit({ value, fee, memo }: sendMsgInitParams): Promise<DeliverTxResponse>;
     sendMsgMint({ value, fee, memo }: sendMsgMintParams): Promise<DeliverTxResponse>;
-    msgInit({ value }: msgInitParams): EncodeObject;
+    sendMsgInit({ value, fee, memo }: sendMsgInitParams): Promise<DeliverTxResponse>;
     msgMint({ value }: msgMintParams): EncodeObject;
+    msgInit({ value }: msgInitParams): EncodeObject;
 };
 interface QueryClientOptions {
     addr: string;

package/types/iconlake.drop/types/iconlake/drop/info.d.ts

@@ -4,6 +4,10 @@ export interface Info {
     address: string;
     lastMintTime: number;
 }
+export interface InfoRaw {
+    accAddress: Uint8Array;
+    lastMintTime: number;
+}
 export declare const Info: {
     encode(message: Info, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): Info;
@@ -17,6 +21,19 @@ export declare const Info: {
         lastMintTime?: number;
     } & { [K in Exclude<keyof I, keyof Info>]: never; }>(object: I): Info;
 };
+export declare const InfoRaw: {
+    encode(message: InfoRaw, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InfoRaw;
+    fromJSON(object: any): InfoRaw;
+    toJSON(message: InfoRaw): unknown;
+    fromPartial<I extends {
+        accAddress?: Uint8Array;
+        lastMintTime?: number;
+    } & {
+        accAddress?: Uint8Array;
+        lastMintTime?: number;
+    } & { [K in Exclude<keyof I, keyof InfoRaw>]: never; }>(object: I): InfoRaw;
+};
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;

package/types/iconlake.drop/types.d.ts

@@ -1,3 +1,4 @@
 import { Info } from "./types/iconlake/drop/info";
+import { InfoRaw } from "./types/iconlake/drop/info";
 import { Params } from "./types/iconlake/drop/params";
-export { Info, Params, };
+export { Info, InfoRaw, Params, };

package/types/iconlake.icon/module.d.ts

@@ -4,15 +4,24 @@ import { EncodeObject, GeneratedType, OfflineSigner, Registry } from "@cosmjs/pr
 import { IgniteClient } from "../client";
 import { Api } from "./rest";
 import { MsgMint } from "./types/iconlake/icon/tx";
-export { MsgMint };
+import { MsgUpdateClass } from "./types/iconlake/icon/tx";
+export { MsgMint, MsgUpdateClass };
 type sendMsgMintParams = {
     value: MsgMint;
     fee?: StdFee;
     memo?: string;
 };
+type sendMsgUpdateClassParams = {
+    value: MsgUpdateClass;
+    fee?: StdFee;
+    memo?: string;
+};
 type msgMintParams = {
     value: MsgMint;
 };
+type msgUpdateClassParams = {
+    value: MsgUpdateClass;
+};
 export declare const registry: Registry;
 interface TxClientOptions {
     addr: string;
@@ -21,7 +30,9 @@ interface TxClientOptions {
 }
 export declare const txClient: ({ signer, prefix, addr }?: TxClientOptions) => {
     sendMsgMint({ value, fee, memo }: sendMsgMintParams): Promise<DeliverTxResponse>;
+    sendMsgUpdateClass({ value, fee, memo }: sendMsgUpdateClassParams): Promise<DeliverTxResponse>;
     msgMint({ value }: msgMintParams): EncodeObject;
+    msgUpdateClass({ value }: msgUpdateClassParams): EncodeObject;
 };
 interface QueryClientOptions {
     addr: string;

package/types/iconlake.icon/rest.d.ts

@@ -1,10 +1,17 @@
+export interface IconClassData {
+    author?: string;
+    /** @format int64 */
+    createTime?: string;
+}
 export interface IconIconData {
     author?: string;
     name?: string;
     description?: string;
+    /** @format int64 */
     createTime?: string;
 }
 export type IconMsgMintResponse = object;
+export type IconMsgUpdateClassResponse = object;
 /**
  * Params defines the parameters for the module.
  */
@@ -24,7 +31,165 @@ export interface IconQueryParamsResponse {
     /** params holds all the parameters of this module. */
     params?: IconParams;
 }
+export interface IconlakeiconClass {
+    id?: string;
+    name?: string;
+    symbol?: string;
+    description?: string;
+    uri?: string;
+    uriHash?: string;
+    data?: IconClassData;
+}
+export interface IconlakeiconNFT {
+    classId?: string;
+    id?: string;
+    uri?: string;
+    uriHash?: string;
+    data?: IconIconData;
+}
+export interface IconlakeiconQueryClassResponse {
+    class?: IconlakeiconClass;
+}
+export interface IconlakeiconQueryClassesResponse {
+    classes?: IconlakeiconClass[];
+    /**
+     * PageResponse is to be embedded in gRPC response messages where the
+     * corresponding request message has used PageRequest.
+     *
+     *  message SomeResponse {
+     *          repeated Bar results = 1;
+     *          PageResponse page = 2;
+     *  }
+     */
+    pagination?: V1Beta1PageResponse;
+}
+export interface IconlakeiconQueryNFTResponse {
+    nft?: IconlakeiconNFT;
+}
+export interface IconlakeiconQueryNFTsResponse {
+    nfts?: IconlakeiconNFT[];
+    /**
+     * PageResponse is to be embedded in gRPC response messages where the
+     * corresponding request message has used PageRequest.
+     *
+     *  message SomeResponse {
+     *          repeated Bar results = 1;
+     *          PageResponse page = 2;
+     *  }
+     */
+    pagination?: V1Beta1PageResponse;
+}
+/**
+* `Any` contains an arbitrary serialized protocol buffer message along with a
+URL that describes the type of the serialized message.
+
+Protobuf library provides support to pack/unpack Any values in the form
+of utility functions or additional generated methods of the Any type.
+
+Example 1: Pack and unpack a message in C++.
+
+    Foo foo = ...;
+    Any any;
+    any.PackFrom(foo);
+    ...
+    if (any.UnpackTo(&foo)) {
+      ...
+    }
+
+Example 2: Pack and unpack a message in Java.
+
+    Foo foo = ...;
+    Any any = Any.pack(foo);
+    ...
+    if (any.is(Foo.class)) {
+      foo = any.unpack(Foo.class);
+    }
+
+ Example 3: Pack and unpack a message in Python.
+
+    foo = Foo(...)
+    any = Any()
+    any.Pack(foo)
+    ...
+    if any.Is(Foo.DESCRIPTOR):
+      any.Unpack(foo)
+      ...
+
+ Example 4: Pack and unpack a message in Go
+
+     foo := &pb.Foo{...}
+     any, err := anypb.New(foo)
+     if err != nil {
+       ...
+     }
+     ...
+     foo := &pb.Foo{}
+     if err := any.UnmarshalTo(foo); err != nil {
+       ...
+     }
+
+The pack methods provided by protobuf library will by default use
+'type.googleapis.com/full.type.name' as the type URL and the unpack
+methods only use the fully qualified type name after the last '/'
+in the type URL, for example "foo.bar.com/x/y.z" will yield type
+name "y.z".
+
+
+JSON
+====
+The JSON representation of an `Any` value uses the regular
+representation of the deserialized, embedded message, with an
+additional field `@type` which contains the type URL. Example:
+
+    package google.profile;
+    message Person {
+      string first_name = 1;
+      string last_name = 2;
+    }
+
+    {
+      "@type": "type.googleapis.com/google.profile.Person",
+      "firstName": <string>,
+      "lastName": <string>
+    }
+
+If the embedded message type is well-known and has a custom JSON
+representation, that representation will be embedded adding a field
+`value` which holds the custom JSON in addition to the `@type`
+field. Example (for message [google.protobuf.Duration][]):
+
+    {
+      "@type": "type.googleapis.com/google.protobuf.Duration",
+      "value": "1.212s"
+    }
+*/
 export interface ProtobufAny {
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com.
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     */
     "@type"?: string;
 }
 export interface RpcStatus {
@@ -33,6 +198,71 @@ export interface RpcStatus {
     message?: string;
     details?: ProtobufAny[];
 }
+/**
+* message SomeRequest {
+         Foo some_parameter = 1;
+         PageRequest pagination = 2;
+ }
+*/
+export interface V1Beta1PageRequest {
+    /**
+     * key is a value returned in PageResponse.next_key to begin
+     * querying the next page most efficiently. Only one of offset or key
+     * should be set.
+     * @format byte
+     */
+    key?: string;
+    /**
+     * offset is a numeric offset that can be used when key is unavailable.
+     * It is less efficient than using key. Only one of offset or key should
+     * be set.
+     * @format uint64
+     */
+    offset?: string;
+    /**
+     * limit is the total number of results to be returned in the result page.
+     * If left empty it will default to a value to be set by each app.
+     * @format uint64
+     */
+    limit?: string;
+    /**
+     * count_total is set to true  to indicate that the result set should include
+     * a count of the total number of items available for pagination in UIs.
+     * count_total is only respected when offset is used. It is ignored when key
+     * is set.
+     */
+    count_total?: boolean;
+    /**
+     * reverse is set to true if results are to be returned in the descending order.
+     *
+     * Since: cosmos-sdk 0.43
+     */
+    reverse?: boolean;
+}
+/**
+* PageResponse is to be embedded in gRPC response messages where the
+corresponding request message has used PageRequest.
+
+ message SomeResponse {
+         repeated Bar results = 1;
+         PageResponse page = 2;
+ }
+*/
+export interface V1Beta1PageResponse {
+    /**
+     * next_key is the key to be passed to PageRequest.key to
+     * query the next page most efficiently. It will be empty if
+     * there are no more results.
+     * @format byte
+     */
+    next_key?: string;
+    /**
+     * total is total number of results available if PageRequest.count_total
+     * was set, its value is undefined otherwise
+     * @format uint64
+     */
+    total?: string;
+}
 import { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
 export type QueryParamsType = Record<string | number, any>;
 export interface FullRequestParams extends Omit<AxiosRequestConfig, "data" | "params" | "url" | "responseType"> {
@@ -77,15 +307,65 @@ export declare class HttpClient<SecurityDataType = unknown> {
  * @version version not set
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryClass
+     * @summary Queries a class info.
+     * @request GET:/iconlake/icon/class/{id}
+     */
+    queryClass: (id: string, params?: RequestParams) => Promise<AxiosResponse<IconlakeiconQueryClassResponse>>;
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryClasses
+     * @summary Queries a list of Class items.
+     * @request GET:/iconlake/icon/classes
+     */
+    queryClasses: (query?: {
+        "pagination.key"?: string;
+        "pagination.offset"?: string;
+        "pagination.limit"?: string;
+        "pagination.count_total"?: boolean;
+        "pagination.reverse"?: boolean;
+    }, params?: RequestParams) => Promise<AxiosResponse<IconlakeiconQueryClassesResponse>>;
     /**
      * No description
      *
      * @tags Query
      * @name QueryHash
-     * @summary Queries a list of Hash items.
+     * @summary Queries hash of a uri.
      * @request POST:/iconlake/icon/hash
      */
     queryHash: (body: IconQueryHashRequest, params?: RequestParams) => Promise<AxiosResponse<IconQueryHashResponse>>;
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryNft
+     * @summary Queries a NFT info.
+     * @request GET:/iconlake/icon/nft/{classId}/{id}
+     */
+    queryNFT: (classId: string, id: string, params?: RequestParams) => Promise<AxiosResponse<IconlakeiconQueryNFTResponse>>;
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryNfTs
+     * @summary Queries a list of NFTs of a class.
+     * @request GET:/iconlake/icon/nfts
+     */
+    queryNFTs: (query?: {
+        class_id?: string;
+        owner?: string;
+        "pagination.key"?: string;
+        "pagination.offset"?: string;
+        "pagination.limit"?: string;
+        "pagination.count_total"?: boolean;
+        "pagination.reverse"?: boolean;
+    }, params?: RequestParams) => Promise<AxiosResponse<IconlakeiconQueryNFTsResponse>>;
     /**
      * No description
      *

package/types/iconlake.icon/types/cosmos/nft/v1beta1/nft.d.ts

@@ -0,0 +1,104 @@
+import _m0 from "protobufjs/minimal";
+import { Any } from "../../../google/protobuf/any";
+export declare const protobufPackage = "cosmos.nft.v1beta1";
+/** 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 | undefined;
+}
+/** 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 | undefined;
+}
+export declare const Class: {
+    encode(message: Class, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Class;
+    fromJSON(object: any): Class;
+    toJSON(message: Class): unknown;
+    fromPartial<I extends {
+        id?: string;
+        name?: string;
+        symbol?: string;
+        description?: string;
+        uri?: string;
+        uriHash?: string;
+        data?: {
+            typeUrl?: string;
+            value?: Uint8Array;
+        };
+    } & {
+        id?: string;
+        name?: string;
+        symbol?: string;
+        description?: string;
+        uri?: string;
+        uriHash?: string;
+        data?: {
+            typeUrl?: string;
+            value?: Uint8Array;
+        } & {
+            typeUrl?: string;
+            value?: Uint8Array;
+        } & { [K in Exclude<keyof I["data"], keyof Any>]: never; };
+    } & { [K_1 in Exclude<keyof I, keyof Class>]: never; }>(object: I): Class;
+};
+export declare const NFT: {
+    encode(message: NFT, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): NFT;
+    fromJSON(object: any): NFT;
+    toJSON(message: NFT): unknown;
+    fromPartial<I extends {
+        classId?: string;
+        id?: string;
+        uri?: string;
+        uriHash?: string;
+        data?: {
+            typeUrl?: string;
+            value?: Uint8Array;
+        };
+    } & {
+        classId?: string;
+        id?: string;
+        uri?: string;
+        uriHash?: string;
+        data?: {
+            typeUrl?: string;
+            value?: Uint8Array;
+        } & {
+            typeUrl?: string;
+            value?: Uint8Array;
+        } & { [K in Exclude<keyof I["data"], keyof Any>]: never; };
+    } & { [K_1 in Exclude<keyof I, keyof NFT>]: never; }>(object: I): NFT;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};