@sparkdreamnft/sparkdreamjs 0.0.42 → 0.0.44

package/sparkdream/artifact/v1/query.lcd.d.ts

@@ -0,0 +1,27 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse, QueryClassesByOwnerRequest, QueryClassesByOwnerResponse, QueryTokenRequest, QueryTokenResponse, QueryTokensRequest, QueryTokensResponse, QueryTokensByOwnerRequest, QueryTokensByOwnerResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryListingRequest, QueryListingResponse, QueryListingsRequest, QueryListingsResponse, QueryListingsBySellerRequest, QueryListingsBySellerResponse, QueryInboxRequest, QueryInboxResponse, QueryOutboxRequest, QueryOutboxResponse, QueryReceivePolicyRequest, QueryReceivePolicyResponse, QueryPendingClassOwnerRequest, QueryPendingClassOwnerResponse, QueryHideRecordRequest, QueryHideRecordResponse, QueryHideRecordsByTargetRequest, QueryHideRecordsByTargetResponse, QueryPublicMintQuoteRequest, QueryPublicMintQuoteResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    class: (params: QueryClassRequest) => Promise<QueryClassResponse>;
+    classes: (params?: QueryClassesRequest) => Promise<QueryClassesResponse>;
+    classesByOwner: (params: QueryClassesByOwnerRequest) => Promise<QueryClassesByOwnerResponse>;
+    token: (params: QueryTokenRequest) => Promise<QueryTokenResponse>;
+    tokens: (params: QueryTokensRequest) => Promise<QueryTokensResponse>;
+    tokensByOwner: (params: QueryTokensByOwnerRequest) => Promise<QueryTokensByOwnerResponse>;
+    owner: (params: QueryOwnerRequest) => Promise<QueryOwnerResponse>;
+    supply: (params: QuerySupplyRequest) => Promise<QuerySupplyResponse>;
+    listing: (params: QueryListingRequest) => Promise<QueryListingResponse>;
+    listings: (params: QueryListingsRequest) => Promise<QueryListingsResponse>;
+    listingsBySeller: (params: QueryListingsBySellerRequest) => Promise<QueryListingsBySellerResponse>;
+    inbox: (params: QueryInboxRequest) => Promise<QueryInboxResponse>;
+    outbox: (params: QueryOutboxRequest) => Promise<QueryOutboxResponse>;
+    receivePolicy: (params: QueryReceivePolicyRequest) => Promise<QueryReceivePolicyResponse>;
+    pendingClassOwner: (params: QueryPendingClassOwnerRequest) => Promise<QueryPendingClassOwnerResponse>;
+    hideRecord: (params: QueryHideRecordRequest) => Promise<QueryHideRecordResponse>;
+    hideRecordsByTarget: (params: QueryHideRecordsByTargetRequest) => Promise<QueryHideRecordsByTargetResponse>;
+    publicMintQuote: (params: QueryPublicMintQuoteRequest) => Promise<QueryPublicMintQuoteResponse>;
+}

package/sparkdream/artifact/v1/query.lcd.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+//@ts-nocheck
+const helpers_1 = require("../../../helpers");
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/artifact/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* Class returns one class. */
+    class = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/class/${params.classId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Classes lists all classes. */
+    classes = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/classes`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ClassesByOwner lists the classes an address owns. */
+    classesByOwner = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/classes_by_owner/${params.owner}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Token returns one token. */
+    token = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/token/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Tokens lists the tokens of a class. */
+    tokens = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/tokens/${params.classId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* TokensByOwner lists the tokens an address owns. */
+    tokensByOwner = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.classId !== "undefined") {
+            options.params.class_id = params.classId;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/tokens_by_owner/${params.owner}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Owner returns a token's owner. */
+    owner = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/owner/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Supply returns a class's supply counters. */
+    supply = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/supply/${params.classId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Listing returns a token's active listing. */
+    listing = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/listing/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Listings lists active listings, optionally for one class. */
+    listings = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.classId !== "undefined") {
+            options.params.class_id = params.classId;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/listings`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ListingsBySeller lists a seller's active listings. */
+    listingsBySeller = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/listings_by_seller/${params.seller}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Inbox lists an address's open incoming items. */
+    inbox = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/inbox/${params.address}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Outbox lists an address's open outgoing items. */
+    outbox = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/outbox/${params.address}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ReceivePolicy returns an address's effective receive policy. */
+    receivePolicy = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/receive_policy/${params.address}`;
+        return await this.req.get(endpoint);
+    };
+    /* PendingClassOwner returns a class's open handover proposal. */
+    pendingClassOwner = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/pending_class_owner/${params.classId}`;
+        return await this.req.get(endpoint);
+    };
+    /* HideRecord returns one hide record. */
+    hideRecord = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/hide_record/${params.hideId}`;
+        return await this.req.get(endpoint);
+    };
+    /* HideRecordsByTarget lists every hide record for a class (token_id 0) or token. */
+    hideRecordsByTarget = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/hide_records_by_target/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* PublicMintQuote prices a public mint. */
+    publicMintQuote = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/public_mint_quote/${params.classId}/${params.buyer}/${params.quantity}`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/sparkdream/artifact/v1/query.rpc.Query.d.ts

@@ -0,0 +1,88 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse, QueryClassesByOwnerRequest, QueryClassesByOwnerResponse, QueryTokenRequest, QueryTokenResponse, QueryTokensRequest, QueryTokensResponse, QueryTokensByOwnerRequest, QueryTokensByOwnerResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryListingRequest, QueryListingResponse, QueryListingsRequest, QueryListingsResponse, QueryListingsBySellerRequest, QueryListingsBySellerResponse, QueryInboxRequest, QueryInboxResponse, QueryOutboxRequest, QueryOutboxResponse, QueryReceivePolicyRequest, QueryReceivePolicyResponse, QueryPendingClassOwnerRequest, QueryPendingClassOwnerResponse, QueryHideRecordRequest, QueryHideRecordResponse, QueryHideRecordsByTargetRequest, QueryHideRecordsByTargetResponse, QueryPublicMintQuoteRequest, QueryPublicMintQuoteResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Parameters queries the parameters of the module. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** Class returns one class. */
+    class(request: QueryClassRequest): Promise<QueryClassResponse>;
+    /** Classes lists all classes. */
+    classes(request?: QueryClassesRequest): Promise<QueryClassesResponse>;
+    /** ClassesByOwner lists the classes an address owns. */
+    classesByOwner(request: QueryClassesByOwnerRequest): Promise<QueryClassesByOwnerResponse>;
+    /** Token returns one token. */
+    token(request: QueryTokenRequest): Promise<QueryTokenResponse>;
+    /** Tokens lists the tokens of a class. */
+    tokens(request: QueryTokensRequest): Promise<QueryTokensResponse>;
+    /** TokensByOwner lists the tokens an address owns. */
+    tokensByOwner(request: QueryTokensByOwnerRequest): Promise<QueryTokensByOwnerResponse>;
+    /** Owner returns a token's owner. */
+    owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse>;
+    /** Supply returns a class's supply counters. */
+    supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse>;
+    /** Listing returns a token's active listing. */
+    listing(request: QueryListingRequest): Promise<QueryListingResponse>;
+    /** Listings lists active listings, optionally for one class. */
+    listings(request: QueryListingsRequest): Promise<QueryListingsResponse>;
+    /** ListingsBySeller lists a seller's active listings. */
+    listingsBySeller(request: QueryListingsBySellerRequest): Promise<QueryListingsBySellerResponse>;
+    /** Inbox lists an address's open incoming items. */
+    inbox(request: QueryInboxRequest): Promise<QueryInboxResponse>;
+    /** Outbox lists an address's open outgoing items. */
+    outbox(request: QueryOutboxRequest): Promise<QueryOutboxResponse>;
+    /** ReceivePolicy returns an address's effective receive policy. */
+    receivePolicy(request: QueryReceivePolicyRequest): Promise<QueryReceivePolicyResponse>;
+    /** PendingClassOwner returns a class's open handover proposal. */
+    pendingClassOwner(request: QueryPendingClassOwnerRequest): Promise<QueryPendingClassOwnerResponse>;
+    /** HideRecord returns one hide record. */
+    hideRecord(request: QueryHideRecordRequest): Promise<QueryHideRecordResponse>;
+    /** HideRecordsByTarget lists every hide record for a class (token_id 0) or token. */
+    hideRecordsByTarget(request: QueryHideRecordsByTargetRequest): Promise<QueryHideRecordsByTargetResponse>;
+    /** PublicMintQuote prices a public mint. */
+    publicMintQuote(request: QueryPublicMintQuoteRequest): Promise<QueryPublicMintQuoteResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    class: (request: QueryClassRequest) => Promise<QueryClassResponse>;
+    classes: (request?: QueryClassesRequest) => Promise<QueryClassesResponse>;
+    classesByOwner: (request: QueryClassesByOwnerRequest) => Promise<QueryClassesByOwnerResponse>;
+    token: (request: QueryTokenRequest) => Promise<QueryTokenResponse>;
+    tokens: (request: QueryTokensRequest) => Promise<QueryTokensResponse>;
+    tokensByOwner: (request: QueryTokensByOwnerRequest) => Promise<QueryTokensByOwnerResponse>;
+    owner: (request: QueryOwnerRequest) => Promise<QueryOwnerResponse>;
+    supply: (request: QuerySupplyRequest) => Promise<QuerySupplyResponse>;
+    listing: (request: QueryListingRequest) => Promise<QueryListingResponse>;
+    listings: (request: QueryListingsRequest) => Promise<QueryListingsResponse>;
+    listingsBySeller: (request: QueryListingsBySellerRequest) => Promise<QueryListingsBySellerResponse>;
+    inbox: (request: QueryInboxRequest) => Promise<QueryInboxResponse>;
+    outbox: (request: QueryOutboxRequest) => Promise<QueryOutboxResponse>;
+    receivePolicy: (request: QueryReceivePolicyRequest) => Promise<QueryReceivePolicyResponse>;
+    pendingClassOwner: (request: QueryPendingClassOwnerRequest) => Promise<QueryPendingClassOwnerResponse>;
+    hideRecord: (request: QueryHideRecordRequest) => Promise<QueryHideRecordResponse>;
+    hideRecordsByTarget: (request: QueryHideRecordsByTargetRequest) => Promise<QueryHideRecordsByTargetResponse>;
+    publicMintQuote: (request: QueryPublicMintQuoteRequest) => Promise<QueryPublicMintQuoteResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    class(request: QueryClassRequest): Promise<QueryClassResponse>;
+    classes(request?: QueryClassesRequest): Promise<QueryClassesResponse>;
+    classesByOwner(request: QueryClassesByOwnerRequest): Promise<QueryClassesByOwnerResponse>;
+    token(request: QueryTokenRequest): Promise<QueryTokenResponse>;
+    tokens(request: QueryTokensRequest): Promise<QueryTokensResponse>;
+    tokensByOwner(request: QueryTokensByOwnerRequest): Promise<QueryTokensByOwnerResponse>;
+    owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse>;
+    supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse>;
+    listing(request: QueryListingRequest): Promise<QueryListingResponse>;
+    listings(request: QueryListingsRequest): Promise<QueryListingsResponse>;
+    listingsBySeller(request: QueryListingsBySellerRequest): Promise<QueryListingsBySellerResponse>;
+    inbox(request: QueryInboxRequest): Promise<QueryInboxResponse>;
+    outbox(request: QueryOutboxRequest): Promise<QueryOutboxResponse>;
+    receivePolicy(request: QueryReceivePolicyRequest): Promise<QueryReceivePolicyResponse>;
+    pendingClassOwner(request: QueryPendingClassOwnerRequest): Promise<QueryPendingClassOwnerResponse>;
+    hideRecord(request: QueryHideRecordRequest): Promise<QueryHideRecordResponse>;
+    hideRecordsByTarget(request: QueryHideRecordsByTargetRequest): Promise<QueryHideRecordsByTargetResponse>;
+    publicMintQuote(request: QueryPublicMintQuoteRequest): Promise<QueryPublicMintQuoteResponse>;
+};

package/sparkdream/artifact/v1/query.rpc.Query.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Class returns one class. */
+    class = async (request) => {
+        const data = query_1.QueryClassRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Class", data);
+        return promise.then(data => query_1.QueryClassResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Classes lists all classes. */
+    classes = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryClassesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Classes", data);
+        return promise.then(data => query_1.QueryClassesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ClassesByOwner lists the classes an address owns. */
+    classesByOwner = async (request) => {
+        const data = query_1.QueryClassesByOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "ClassesByOwner", data);
+        return promise.then(data => query_1.QueryClassesByOwnerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Token returns one token. */
+    token = async (request) => {
+        const data = query_1.QueryTokenRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Token", data);
+        return promise.then(data => query_1.QueryTokenResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Tokens lists the tokens of a class. */
+    tokens = async (request) => {
+        const data = query_1.QueryTokensRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Tokens", data);
+        return promise.then(data => query_1.QueryTokensResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* TokensByOwner lists the tokens an address owns. */
+    tokensByOwner = async (request) => {
+        const data = query_1.QueryTokensByOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "TokensByOwner", data);
+        return promise.then(data => query_1.QueryTokensByOwnerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Owner returns a token's owner. */
+    owner = async (request) => {
+        const data = query_1.QueryOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Owner", data);
+        return promise.then(data => query_1.QueryOwnerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Supply returns a class's supply counters. */
+    supply = async (request) => {
+        const data = query_1.QuerySupplyRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Supply", data);
+        return promise.then(data => query_1.QuerySupplyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Listing returns a token's active listing. */
+    listing = async (request) => {
+        const data = query_1.QueryListingRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Listing", data);
+        return promise.then(data => query_1.QueryListingResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Listings lists active listings, optionally for one class. */
+    listings = async (request) => {
+        const data = query_1.QueryListingsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Listings", data);
+        return promise.then(data => query_1.QueryListingsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListingsBySeller lists a seller's active listings. */
+    listingsBySeller = async (request) => {
+        const data = query_1.QueryListingsBySellerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "ListingsBySeller", data);
+        return promise.then(data => query_1.QueryListingsBySellerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Inbox lists an address's open incoming items. */
+    inbox = async (request) => {
+        const data = query_1.QueryInboxRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Inbox", data);
+        return promise.then(data => query_1.QueryInboxResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Outbox lists an address's open outgoing items. */
+    outbox = async (request) => {
+        const data = query_1.QueryOutboxRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Outbox", data);
+        return promise.then(data => query_1.QueryOutboxResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ReceivePolicy returns an address's effective receive policy. */
+    receivePolicy = async (request) => {
+        const data = query_1.QueryReceivePolicyRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "ReceivePolicy", data);
+        return promise.then(data => query_1.QueryReceivePolicyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* PendingClassOwner returns a class's open handover proposal. */
+    pendingClassOwner = async (request) => {
+        const data = query_1.QueryPendingClassOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "PendingClassOwner", data);
+        return promise.then(data => query_1.QueryPendingClassOwnerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* HideRecord returns one hide record. */
+    hideRecord = async (request) => {
+        const data = query_1.QueryHideRecordRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "HideRecord", data);
+        return promise.then(data => query_1.QueryHideRecordResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* HideRecordsByTarget lists every hide record for a class (token_id 0) or token. */
+    hideRecordsByTarget = async (request) => {
+        const data = query_1.QueryHideRecordsByTargetRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "HideRecordsByTarget", data);
+        return promise.then(data => query_1.QueryHideRecordsByTargetResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* PublicMintQuote prices a public mint. */
+    publicMintQuote = async (request) => {
+        const data = query_1.QueryPublicMintQuoteRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "PublicMintQuote", data);
+        return promise.then(data => query_1.QueryPublicMintQuoteResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        class(request) {
+            return queryService.class(request);
+        },
+        classes(request) {
+            return queryService.classes(request);
+        },
+        classesByOwner(request) {
+            return queryService.classesByOwner(request);
+        },
+        token(request) {
+            return queryService.token(request);
+        },
+        tokens(request) {
+            return queryService.tokens(request);
+        },
+        tokensByOwner(request) {
+            return queryService.tokensByOwner(request);
+        },
+        owner(request) {
+            return queryService.owner(request);
+        },
+        supply(request) {
+            return queryService.supply(request);
+        },
+        listing(request) {
+            return queryService.listing(request);
+        },
+        listings(request) {
+            return queryService.listings(request);
+        },
+        listingsBySeller(request) {
+            return queryService.listingsBySeller(request);
+        },
+        inbox(request) {
+            return queryService.inbox(request);
+        },
+        outbox(request) {
+            return queryService.outbox(request);
+        },
+        receivePolicy(request) {
+            return queryService.receivePolicy(request);
+        },
+        pendingClassOwner(request) {
+            return queryService.pendingClassOwner(request);
+        },
+        hideRecord(request) {
+            return queryService.hideRecord(request);
+        },
+        hideRecordsByTarget(request) {
+            return queryService.hideRecordsByTarget(request);
+        },
+        publicMintQuote(request) {
+            return queryService.publicMintQuote(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/sparkdream/artifact/v1/tx.amino.d.ts

@@ -0,0 +1,158 @@
+import { MsgUpdateParams, MsgCreateClass, MsgUpdateClass, MsgFreezeClassMetadata, MsgSetMintPolicy, MsgSetMinters, MsgSetMaxSupply, MsgCloseMinting, MsgProposeClassOwner, MsgAcceptClassOwner, MsgCancelClassOwner, MsgDeleteClass, MsgMint, MsgPublicMint, MsgTransfer, MsgAcceptIncoming, MsgRejectIncoming, MsgCancelOutgoing, MsgSetReceivePolicy, MsgBurn, MsgRevoke, MsgUpdateToken, MsgFreezeTokenMetadata, MsgList, MsgUpdateListing, MsgDelist, MsgBuy, MsgHideContent, MsgUnhideContent, MsgAppealHide, MsgUpdateOperationalParams } from "./tx";
+export declare const AminoConverter: {
+    "/sparkdream.artifact.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.artifact.v1.MsgCreateClass": {
+        aminoType: string;
+        toAmino: (message: MsgCreateClass) => import("./tx").MsgCreateClassAmino;
+        fromAmino: (object: import("./tx").MsgCreateClassAmino) => MsgCreateClass;
+    };
+    "/sparkdream.artifact.v1.MsgUpdateClass": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateClass) => import("./tx").MsgUpdateClassAmino;
+        fromAmino: (object: import("./tx").MsgUpdateClassAmino) => MsgUpdateClass;
+    };
+    "/sparkdream.artifact.v1.MsgFreezeClassMetadata": {
+        aminoType: string;
+        toAmino: (message: MsgFreezeClassMetadata) => import("./tx").MsgFreezeClassMetadataAmino;
+        fromAmino: (object: import("./tx").MsgFreezeClassMetadataAmino) => MsgFreezeClassMetadata;
+    };
+    "/sparkdream.artifact.v1.MsgSetMintPolicy": {
+        aminoType: string;
+        toAmino: (message: MsgSetMintPolicy) => import("./tx").MsgSetMintPolicyAmino;
+        fromAmino: (object: import("./tx").MsgSetMintPolicyAmino) => MsgSetMintPolicy;
+    };
+    "/sparkdream.artifact.v1.MsgSetMinters": {
+        aminoType: string;
+        toAmino: (message: MsgSetMinters) => import("./tx").MsgSetMintersAmino;
+        fromAmino: (object: import("./tx").MsgSetMintersAmino) => MsgSetMinters;
+    };
+    "/sparkdream.artifact.v1.MsgSetMaxSupply": {
+        aminoType: string;
+        toAmino: (message: MsgSetMaxSupply) => import("./tx").MsgSetMaxSupplyAmino;
+        fromAmino: (object: import("./tx").MsgSetMaxSupplyAmino) => MsgSetMaxSupply;
+    };
+    "/sparkdream.artifact.v1.MsgCloseMinting": {
+        aminoType: string;
+        toAmino: (message: MsgCloseMinting) => import("./tx").MsgCloseMintingAmino;
+        fromAmino: (object: import("./tx").MsgCloseMintingAmino) => MsgCloseMinting;
+    };
+    "/sparkdream.artifact.v1.MsgProposeClassOwner": {
+        aminoType: string;
+        toAmino: (message: MsgProposeClassOwner) => import("./tx").MsgProposeClassOwnerAmino;
+        fromAmino: (object: import("./tx").MsgProposeClassOwnerAmino) => MsgProposeClassOwner;
+    };
+    "/sparkdream.artifact.v1.MsgAcceptClassOwner": {
+        aminoType: string;
+        toAmino: (message: MsgAcceptClassOwner) => import("./tx").MsgAcceptClassOwnerAmino;
+        fromAmino: (object: import("./tx").MsgAcceptClassOwnerAmino) => MsgAcceptClassOwner;
+    };
+    "/sparkdream.artifact.v1.MsgCancelClassOwner": {
+        aminoType: string;
+        toAmino: (message: MsgCancelClassOwner) => import("./tx").MsgCancelClassOwnerAmino;
+        fromAmino: (object: import("./tx").MsgCancelClassOwnerAmino) => MsgCancelClassOwner;
+    };
+    "/sparkdream.artifact.v1.MsgDeleteClass": {
+        aminoType: string;
+        toAmino: (message: MsgDeleteClass) => import("./tx").MsgDeleteClassAmino;
+        fromAmino: (object: import("./tx").MsgDeleteClassAmino) => MsgDeleteClass;
+    };
+    "/sparkdream.artifact.v1.MsgMint": {
+        aminoType: string;
+        toAmino: (message: MsgMint) => import("./tx").MsgMintAmino;
+        fromAmino: (object: import("./tx").MsgMintAmino) => MsgMint;
+    };
+    "/sparkdream.artifact.v1.MsgPublicMint": {
+        aminoType: string;
+        toAmino: (message: MsgPublicMint) => import("./tx").MsgPublicMintAmino;
+        fromAmino: (object: import("./tx").MsgPublicMintAmino) => MsgPublicMint;
+    };
+    "/sparkdream.artifact.v1.MsgTransfer": {
+        aminoType: string;
+        toAmino: (message: MsgTransfer) => import("./tx").MsgTransferAmino;
+        fromAmino: (object: import("./tx").MsgTransferAmino) => MsgTransfer;
+    };
+    "/sparkdream.artifact.v1.MsgAcceptIncoming": {
+        aminoType: string;
+        toAmino: (message: MsgAcceptIncoming) => import("./tx").MsgAcceptIncomingAmino;
+        fromAmino: (object: import("./tx").MsgAcceptIncomingAmino) => MsgAcceptIncoming;
+    };
+    "/sparkdream.artifact.v1.MsgRejectIncoming": {
+        aminoType: string;
+        toAmino: (message: MsgRejectIncoming) => import("./tx").MsgRejectIncomingAmino;
+        fromAmino: (object: import("./tx").MsgRejectIncomingAmino) => MsgRejectIncoming;
+    };
+    "/sparkdream.artifact.v1.MsgCancelOutgoing": {
+        aminoType: string;
+        toAmino: (message: MsgCancelOutgoing) => import("./tx").MsgCancelOutgoingAmino;
+        fromAmino: (object: import("./tx").MsgCancelOutgoingAmino) => MsgCancelOutgoing;
+    };
+    "/sparkdream.artifact.v1.MsgSetReceivePolicy": {
+        aminoType: string;
+        toAmino: (message: MsgSetReceivePolicy) => import("./tx").MsgSetReceivePolicyAmino;
+        fromAmino: (object: import("./tx").MsgSetReceivePolicyAmino) => MsgSetReceivePolicy;
+    };
+    "/sparkdream.artifact.v1.MsgBurn": {
+        aminoType: string;
+        toAmino: (message: MsgBurn) => import("./tx").MsgBurnAmino;
+        fromAmino: (object: import("./tx").MsgBurnAmino) => MsgBurn;
+    };
+    "/sparkdream.artifact.v1.MsgRevoke": {
+        aminoType: string;
+        toAmino: (message: MsgRevoke) => import("./tx").MsgRevokeAmino;
+        fromAmino: (object: import("./tx").MsgRevokeAmino) => MsgRevoke;
+    };
+    "/sparkdream.artifact.v1.MsgUpdateToken": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateToken) => import("./tx").MsgUpdateTokenAmino;
+        fromAmino: (object: import("./tx").MsgUpdateTokenAmino) => MsgUpdateToken;
+    };
+    "/sparkdream.artifact.v1.MsgFreezeTokenMetadata": {
+        aminoType: string;
+        toAmino: (message: MsgFreezeTokenMetadata) => import("./tx").MsgFreezeTokenMetadataAmino;
+        fromAmino: (object: import("./tx").MsgFreezeTokenMetadataAmino) => MsgFreezeTokenMetadata;
+    };
+    "/sparkdream.artifact.v1.MsgList": {
+        aminoType: string;
+        toAmino: (message: MsgList) => import("./tx").MsgListAmino;
+        fromAmino: (object: import("./tx").MsgListAmino) => MsgList;
+    };
+    "/sparkdream.artifact.v1.MsgUpdateListing": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateListing) => import("./tx").MsgUpdateListingAmino;
+        fromAmino: (object: import("./tx").MsgUpdateListingAmino) => MsgUpdateListing;
+    };
+    "/sparkdream.artifact.v1.MsgDelist": {
+        aminoType: string;
+        toAmino: (message: MsgDelist) => import("./tx").MsgDelistAmino;
+        fromAmino: (object: import("./tx").MsgDelistAmino) => MsgDelist;
+    };
+    "/sparkdream.artifact.v1.MsgBuy": {
+        aminoType: string;
+        toAmino: (message: MsgBuy) => import("./tx").MsgBuyAmino;
+        fromAmino: (object: import("./tx").MsgBuyAmino) => MsgBuy;
+    };
+    "/sparkdream.artifact.v1.MsgHideContent": {
+        aminoType: string;
+        toAmino: (message: MsgHideContent) => import("./tx").MsgHideContentAmino;
+        fromAmino: (object: import("./tx").MsgHideContentAmino) => MsgHideContent;
+    };
+    "/sparkdream.artifact.v1.MsgUnhideContent": {
+        aminoType: string;
+        toAmino: (message: MsgUnhideContent) => import("./tx").MsgUnhideContentAmino;
+        fromAmino: (object: import("./tx").MsgUnhideContentAmino) => MsgUnhideContent;
+    };
+    "/sparkdream.artifact.v1.MsgAppealHide": {
+        aminoType: string;
+        toAmino: (message: MsgAppealHide) => import("./tx").MsgAppealHideAmino;
+        fromAmino: (object: import("./tx").MsgAppealHideAmino) => MsgAppealHide;
+    };
+    "/sparkdream.artifact.v1.MsgUpdateOperationalParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateOperationalParams) => import("./tx").MsgUpdateOperationalParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateOperationalParamsAmino) => MsgUpdateOperationalParams;
+    };
+};