@sparkdreamnft/sparkdreamjs 0.0.45 → 0.0.47

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

@@ -151,9 +151,182 @@ export class LCDQueryClient {
         const endpoint = `sparkdream/artifact/v1/hide_records_by_target/${params.classId}/${params.tokenId}`;
         return await this.req.get(endpoint);
     };
+    /* MediaProposals lists the open media proposals of a token. */
+    mediaProposals = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/media_proposals/${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);
     };
+    /* Edition shows one edition of an EDITIONS class. */
+    edition = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/edition/${params.classId}/${params.editionId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Editions lists the editions of a class. */
+    editions = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/editions/${params.classId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Balance shows one address's units of an edition and its claimable
+     retro funding. */
+    balance = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/balance/${params.classId}/${params.editionId}/${params.owner}`;
+        return await this.req.get(endpoint);
+    };
+    /* BalancesByOwner lists every edition balance an address holds. */
+    balancesByOwner = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/balances_by_owner/${params.owner}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* EditionHolders lists the balances of one edition. */
+    editionHolders = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/edition_holders/${params.classId}/${params.editionId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* UnitListing shows one unit listing. */
+    unitListing = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/unit_listing/${params.listingId}`;
+        return await this.req.get(endpoint);
+    };
+    /* UnitListings lists the active unit listings of an edition. */
+    unitListings = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/unit_listings/${params.classId}/${params.editionId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* CraftRecipes lists a class's crafting recipes. */
+    craftRecipes = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/craft_recipes/${params.classId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Rental shows a token's active rental. */
+    rental = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/rental/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* RentalOffer shows a token's open rental offer. */
+    rentalOffer = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/rental_offer/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* RentalsByUser lists the active rentals an address holds as renter. */
+    rentalsByUser = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/rentals_by_user/${params.user}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Children lists the tokens nested directly in a token, with the
+     contents hash MsgBuy and MsgAcceptRental pin. */
+    children = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/children/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* HarbergerQuote shows a Harberger token's current price and tax. */
+    harbergerQuote = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/harberger_quote/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Offer shows one escrowed offer. */
+    offer = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/offer/${params.offerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Offers lists the open offers on a token (token_id 0 = collection offers). */
+    offers = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/offers/${params.classId}/${params.tokenId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OffersByBidder lists an address's open offers. */
+    offersByBidder = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/offers_by_bidder/${params.bidder}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Auction shows one auction and the lowest bid it accepts now. */
+    auction = async (params) => {
+        const endpoint = `sparkdream/artifact/v1/auction/${params.auctionId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Auctions lists open auctions (class_id 0 = every class). */
+    auctions = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/auctions/${params.classId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* AuctionsBySeller lists the open auctions started by seller (and the
+     seller's predecessor addresses). */
+    auctionsBySeller = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/auctions_by_seller/${params.seller}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* RentalOffers lists unexpired rental offers. With user set, only the
+     offers addressed to that user (or a predecessor address); otherwise every
+     offer, including the open ones anyone may accept. */
+    rentalOffers = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.user !== "undefined") {
+            options.params.user = params.user;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/artifact/v1/rental_offers`;
+        return await this.req.get(endpoint, options);
+    };
 }

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

@@ -1,6 +1,6 @@
 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";
+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, QueryMediaProposalsRequest, QueryMediaProposalsResponse, QueryPublicMintQuoteRequest, QueryPublicMintQuoteResponse, QueryEditionRequest, QueryEditionResponse, QueryEditionsRequest, QueryEditionsResponse, QueryBalanceRequest, QueryBalanceResponse, QueryBalancesByOwnerRequest, QueryBalancesByOwnerResponse, QueryEditionHoldersRequest, QueryEditionHoldersResponse, QueryUnitListingRequest, QueryUnitListingResponse, QueryUnitListingsRequest, QueryUnitListingsResponse, QueryCraftRecipesRequest, QueryCraftRecipesResponse, QueryRentalRequest, QueryRentalResponse, QueryRentalOfferRequest, QueryRentalOfferResponse, QueryRentalsByUserRequest, QueryRentalsByUserResponse, QueryChildrenRequest, QueryChildrenResponse, QueryHarbergerQuoteRequest, QueryHarbergerQuoteResponse, QueryOfferRequest, QueryOfferResponse, QueryOffersRequest, QueryOffersResponse, QueryOffersByBidderRequest, QueryOffersByBidderResponse, QueryAuctionRequest, QueryAuctionResponse, QueryAuctionsRequest, QueryAuctionsResponse, QueryAuctionsBySellerRequest, QueryAuctionsBySellerResponse, QueryRentalOffersRequest, QueryRentalOffersResponse } from "./query";
 export class QueryClientImpl {
     rpc;
     constructor(rpc) {
@@ -116,12 +116,143 @@ export class QueryClientImpl {
         const promise = this.rpc.request("sparkdream.artifact.v1.Query", "HideRecordsByTarget", data);
         return promise.then(data => QueryHideRecordsByTargetResponse.decode(new BinaryReader(data)));
     };
+    /* MediaProposals lists the open media proposals of a token. */
+    mediaProposals = async (request) => {
+        const data = QueryMediaProposalsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "MediaProposals", data);
+        return promise.then(data => QueryMediaProposalsResponse.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)));
     };
+    /* Edition shows one edition of an EDITIONS class. */
+    edition = async (request) => {
+        const data = QueryEditionRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Edition", data);
+        return promise.then(data => QueryEditionResponse.decode(new BinaryReader(data)));
+    };
+    /* Editions lists the editions of a class. */
+    editions = async (request) => {
+        const data = QueryEditionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Editions", data);
+        return promise.then(data => QueryEditionsResponse.decode(new BinaryReader(data)));
+    };
+    /* Balance shows one address's units of an edition and its claimable
+     retro funding. */
+    balance = async (request) => {
+        const data = QueryBalanceRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Balance", data);
+        return promise.then(data => QueryBalanceResponse.decode(new BinaryReader(data)));
+    };
+    /* BalancesByOwner lists every edition balance an address holds. */
+    balancesByOwner = async (request) => {
+        const data = QueryBalancesByOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "BalancesByOwner", data);
+        return promise.then(data => QueryBalancesByOwnerResponse.decode(new BinaryReader(data)));
+    };
+    /* EditionHolders lists the balances of one edition. */
+    editionHolders = async (request) => {
+        const data = QueryEditionHoldersRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "EditionHolders", data);
+        return promise.then(data => QueryEditionHoldersResponse.decode(new BinaryReader(data)));
+    };
+    /* UnitListing shows one unit listing. */
+    unitListing = async (request) => {
+        const data = QueryUnitListingRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "UnitListing", data);
+        return promise.then(data => QueryUnitListingResponse.decode(new BinaryReader(data)));
+    };
+    /* UnitListings lists the active unit listings of an edition. */
+    unitListings = async (request) => {
+        const data = QueryUnitListingsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "UnitListings", data);
+        return promise.then(data => QueryUnitListingsResponse.decode(new BinaryReader(data)));
+    };
+    /* CraftRecipes lists a class's crafting recipes. */
+    craftRecipes = async (request) => {
+        const data = QueryCraftRecipesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "CraftRecipes", data);
+        return promise.then(data => QueryCraftRecipesResponse.decode(new BinaryReader(data)));
+    };
+    /* Rental shows a token's active rental. */
+    rental = async (request) => {
+        const data = QueryRentalRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Rental", data);
+        return promise.then(data => QueryRentalResponse.decode(new BinaryReader(data)));
+    };
+    /* RentalOffer shows a token's open rental offer. */
+    rentalOffer = async (request) => {
+        const data = QueryRentalOfferRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "RentalOffer", data);
+        return promise.then(data => QueryRentalOfferResponse.decode(new BinaryReader(data)));
+    };
+    /* RentalsByUser lists the active rentals an address holds as renter. */
+    rentalsByUser = async (request) => {
+        const data = QueryRentalsByUserRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "RentalsByUser", data);
+        return promise.then(data => QueryRentalsByUserResponse.decode(new BinaryReader(data)));
+    };
+    /* Children lists the tokens nested directly in a token, with the
+     contents hash MsgBuy and MsgAcceptRental pin. */
+    children = async (request) => {
+        const data = QueryChildrenRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Children", data);
+        return promise.then(data => QueryChildrenResponse.decode(new BinaryReader(data)));
+    };
+    /* HarbergerQuote shows a Harberger token's current price and tax. */
+    harbergerQuote = async (request) => {
+        const data = QueryHarbergerQuoteRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "HarbergerQuote", data);
+        return promise.then(data => QueryHarbergerQuoteResponse.decode(new BinaryReader(data)));
+    };
+    /* Offer shows one escrowed offer. */
+    offer = async (request) => {
+        const data = QueryOfferRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Offer", data);
+        return promise.then(data => QueryOfferResponse.decode(new BinaryReader(data)));
+    };
+    /* Offers lists the open offers on a token (token_id 0 = collection offers). */
+    offers = async (request) => {
+        const data = QueryOffersRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Offers", data);
+        return promise.then(data => QueryOffersResponse.decode(new BinaryReader(data)));
+    };
+    /* OffersByBidder lists an address's open offers. */
+    offersByBidder = async (request) => {
+        const data = QueryOffersByBidderRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "OffersByBidder", data);
+        return promise.then(data => QueryOffersByBidderResponse.decode(new BinaryReader(data)));
+    };
+    /* Auction shows one auction and the lowest bid it accepts now. */
+    auction = async (request) => {
+        const data = QueryAuctionRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Auction", data);
+        return promise.then(data => QueryAuctionResponse.decode(new BinaryReader(data)));
+    };
+    /* Auctions lists open auctions (class_id 0 = every class). */
+    auctions = async (request) => {
+        const data = QueryAuctionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "Auctions", data);
+        return promise.then(data => QueryAuctionsResponse.decode(new BinaryReader(data)));
+    };
+    /* AuctionsBySeller lists the open auctions started by seller (and the
+     seller's predecessor addresses). */
+    auctionsBySeller = async (request) => {
+        const data = QueryAuctionsBySellerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "AuctionsBySeller", data);
+        return promise.then(data => QueryAuctionsBySellerResponse.decode(new BinaryReader(data)));
+    };
+    /* RentalOffers lists unexpired rental offers. With user set, only the
+     offers addressed to that user (or a predecessor address); otherwise every
+     offer, including the open ones anyone may accept. */
+    rentalOffers = async (request) => {
+        const data = QueryRentalOffersRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.artifact.v1.Query", "RentalOffers", data);
+        return promise.then(data => QueryRentalOffersResponse.decode(new BinaryReader(data)));
+    };
 }
 export const createRpcQueryExtension = (base) => {
     const rpc = createProtobufRpcClient(base);
@@ -181,8 +312,71 @@ export const createRpcQueryExtension = (base) => {
         hideRecordsByTarget(request) {
             return queryService.hideRecordsByTarget(request);
         },
+        mediaProposals(request) {
+            return queryService.mediaProposals(request);
+        },
         publicMintQuote(request) {
             return queryService.publicMintQuote(request);
+        },
+        edition(request) {
+            return queryService.edition(request);
+        },
+        editions(request) {
+            return queryService.editions(request);
+        },
+        balance(request) {
+            return queryService.balance(request);
+        },
+        balancesByOwner(request) {
+            return queryService.balancesByOwner(request);
+        },
+        editionHolders(request) {
+            return queryService.editionHolders(request);
+        },
+        unitListing(request) {
+            return queryService.unitListing(request);
+        },
+        unitListings(request) {
+            return queryService.unitListings(request);
+        },
+        craftRecipes(request) {
+            return queryService.craftRecipes(request);
+        },
+        rental(request) {
+            return queryService.rental(request);
+        },
+        rentalOffer(request) {
+            return queryService.rentalOffer(request);
+        },
+        rentalsByUser(request) {
+            return queryService.rentalsByUser(request);
+        },
+        children(request) {
+            return queryService.children(request);
+        },
+        harbergerQuote(request) {
+            return queryService.harbergerQuote(request);
+        },
+        offer(request) {
+            return queryService.offer(request);
+        },
+        offers(request) {
+            return queryService.offers(request);
+        },
+        offersByBidder(request) {
+            return queryService.offersByBidder(request);
+        },
+        auction(request) {
+            return queryService.auction(request);
+        },
+        auctions(request) {
+            return queryService.auctions(request);
+        },
+        auctionsBySeller(request) {
+            return queryService.auctionsBySeller(request);
+        },
+        rentalOffers(request) {
+            return queryService.rentalOffers(request);
         }
     };
 };

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

@@ -1,159 +1,17 @@
 //@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
-    }
-};
+// HAND-WRITTEN OVERRIDE — overlaid on top of the Telescope-generated tx.amino.ts
+// by scripts/codegen.ts after each codegen run. Do not let codegen wipe this.
+//
+// Why: Telescope's generated converters (and the per-message overrides that
+// used to patch them) disagree with the chain's aminojson on empty lists,
+// empty bytes, Dec strings, oneofs and non-nullable messages, and went stale
+// whenever a proto changed. Every Msg of x/artifact is converted by the
+// schema-driven engine in chain-amino.ts instead, which renders amino JSON
+// from the protobuf bytes exactly as the chain does.
+//
+// MAINTENANCE: none per message. The schema (amino-schema.ts, regenerated from
+// the chain on every proto sync) lists every Msg; __tests__/amino-golden.test.ts
+// checks them all against the chain's encoder.
+import * as tx from "./tx";
+import { chainAminoConverters } from "../../../chain-amino";
+export const AminoConverter = chainAminoConverters("sparkdream.artifact.v1", tx);