@sparkdreamnft/sparkdreamjs 0.0.42 → 0.0.44

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

@@ -0,0 +1,159 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export 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") {
+            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") {
+            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") {
+            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") {
+            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") {
+            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") {
+            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") {
+            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") {
+            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);
+    };
+}

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

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

package/esm/sparkdream/artifact/v1/tx.amino.js

@@ -0,0 +1,159 @@
+//@ts-nocheck
+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 const AminoConverter = {
+    "/sparkdream.artifact.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/artifact/MsgUpdateParams",
+        toAmino: MsgUpdateParams.toAmino,
+        fromAmino: MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgCreateClass": {
+        aminoType: "sparkdream/x/artifact/MsgCreateClass",
+        toAmino: MsgCreateClass.toAmino,
+        fromAmino: MsgCreateClass.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgUpdateClass": {
+        aminoType: "sparkdream/x/artifact/MsgUpdateClass",
+        toAmino: MsgUpdateClass.toAmino,
+        fromAmino: MsgUpdateClass.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgFreezeClassMetadata": {
+        aminoType: "sparkdream/x/artifact/MsgFreezeClassMetadata",
+        toAmino: MsgFreezeClassMetadata.toAmino,
+        fromAmino: MsgFreezeClassMetadata.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgSetMintPolicy": {
+        aminoType: "sparkdream/x/artifact/MsgSetMintPolicy",
+        toAmino: MsgSetMintPolicy.toAmino,
+        fromAmino: MsgSetMintPolicy.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgSetMinters": {
+        aminoType: "sparkdream/x/artifact/MsgSetMinters",
+        toAmino: MsgSetMinters.toAmino,
+        fromAmino: MsgSetMinters.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgSetMaxSupply": {
+        aminoType: "sparkdream/x/artifact/MsgSetMaxSupply",
+        toAmino: MsgSetMaxSupply.toAmino,
+        fromAmino: MsgSetMaxSupply.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgCloseMinting": {
+        aminoType: "sparkdream/x/artifact/MsgCloseMinting",
+        toAmino: MsgCloseMinting.toAmino,
+        fromAmino: MsgCloseMinting.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgProposeClassOwner": {
+        aminoType: "sparkdream/x/artifact/MsgProposeClassOwner",
+        toAmino: MsgProposeClassOwner.toAmino,
+        fromAmino: MsgProposeClassOwner.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgAcceptClassOwner": {
+        aminoType: "sparkdream/x/artifact/MsgAcceptClassOwner",
+        toAmino: MsgAcceptClassOwner.toAmino,
+        fromAmino: MsgAcceptClassOwner.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgCancelClassOwner": {
+        aminoType: "sparkdream/x/artifact/MsgCancelClassOwner",
+        toAmino: MsgCancelClassOwner.toAmino,
+        fromAmino: MsgCancelClassOwner.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgDeleteClass": {
+        aminoType: "sparkdream/x/artifact/MsgDeleteClass",
+        toAmino: MsgDeleteClass.toAmino,
+        fromAmino: MsgDeleteClass.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgMint": {
+        aminoType: "sparkdream/x/artifact/MsgMint",
+        toAmino: MsgMint.toAmino,
+        fromAmino: MsgMint.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgPublicMint": {
+        aminoType: "sparkdream/x/artifact/MsgPublicMint",
+        toAmino: MsgPublicMint.toAmino,
+        fromAmino: MsgPublicMint.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgTransfer": {
+        aminoType: "sparkdream/x/artifact/MsgTransfer",
+        toAmino: MsgTransfer.toAmino,
+        fromAmino: MsgTransfer.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgAcceptIncoming": {
+        aminoType: "sparkdream/x/artifact/MsgAcceptIncoming",
+        toAmino: MsgAcceptIncoming.toAmino,
+        fromAmino: MsgAcceptIncoming.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgRejectIncoming": {
+        aminoType: "sparkdream/x/artifact/MsgRejectIncoming",
+        toAmino: MsgRejectIncoming.toAmino,
+        fromAmino: MsgRejectIncoming.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgCancelOutgoing": {
+        aminoType: "sparkdream/x/artifact/MsgCancelOutgoing",
+        toAmino: MsgCancelOutgoing.toAmino,
+        fromAmino: MsgCancelOutgoing.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgSetReceivePolicy": {
+        aminoType: "sparkdream/x/artifact/MsgSetReceivePolicy",
+        toAmino: MsgSetReceivePolicy.toAmino,
+        fromAmino: MsgSetReceivePolicy.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgBurn": {
+        aminoType: "sparkdream/x/artifact/MsgBurn",
+        toAmino: MsgBurn.toAmino,
+        fromAmino: MsgBurn.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgRevoke": {
+        aminoType: "sparkdream/x/artifact/MsgRevoke",
+        toAmino: MsgRevoke.toAmino,
+        fromAmino: MsgRevoke.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgUpdateToken": {
+        aminoType: "sparkdream/x/artifact/MsgUpdateToken",
+        toAmino: MsgUpdateToken.toAmino,
+        fromAmino: MsgUpdateToken.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgFreezeTokenMetadata": {
+        aminoType: "sparkdream/x/artifact/MsgFreezeTokenMetadata",
+        toAmino: MsgFreezeTokenMetadata.toAmino,
+        fromAmino: MsgFreezeTokenMetadata.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgList": {
+        aminoType: "sparkdream/x/artifact/MsgList",
+        toAmino: MsgList.toAmino,
+        fromAmino: MsgList.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgUpdateListing": {
+        aminoType: "sparkdream/x/artifact/MsgUpdateListing",
+        toAmino: MsgUpdateListing.toAmino,
+        fromAmino: MsgUpdateListing.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgDelist": {
+        aminoType: "sparkdream/x/artifact/MsgDelist",
+        toAmino: MsgDelist.toAmino,
+        fromAmino: MsgDelist.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgBuy": {
+        aminoType: "sparkdream/x/artifact/MsgBuy",
+        toAmino: MsgBuy.toAmino,
+        fromAmino: MsgBuy.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgHideContent": {
+        aminoType: "sparkdream/x/artifact/MsgHideContent",
+        toAmino: MsgHideContent.toAmino,
+        fromAmino: MsgHideContent.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgUnhideContent": {
+        aminoType: "sparkdream/x/artifact/MsgUnhideContent",
+        toAmino: MsgUnhideContent.toAmino,
+        fromAmino: MsgUnhideContent.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgAppealHide": {
+        aminoType: "sparkdream/x/artifact/MsgAppealHide",
+        toAmino: MsgAppealHide.toAmino,
+        fromAmino: MsgAppealHide.fromAmino
+    },
+    "/sparkdream.artifact.v1.MsgUpdateOperationalParams": {
+        aminoType: "sparkdream/x/artifact/MsgUpdateOperationalParams",
+        toAmino: MsgUpdateOperationalParams.toAmino,
+        fromAmino: MsgUpdateOperationalParams.fromAmino
+    }
+};