@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

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

@@ -0,0 +1,223 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Params */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/collect/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* Collection */
+    collection = async (params) => {
+        const endpoint = `sparkdream/collect/v1/collection/${params.id}`;
+        return await this.req.get(endpoint);
+    };
+    /* CollectionsByOwner */
+    collectionsByOwner = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/collections_by_owner/${params.owner}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* PublicCollections */
+    publicCollections = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/public_collections`;
+        return await this.req.get(endpoint, options);
+    };
+    /* PublicCollectionsByType */
+    publicCollectionsByType = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/public_collections_by_type/${params.collectionType}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* CollectionsByCollaborator */
+    collectionsByCollaborator = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/collections_by_collaborator/${params.address}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Item */
+    item = async (params) => {
+        const endpoint = `sparkdream/collect/v1/item/${params.id}`;
+        return await this.req.get(endpoint);
+    };
+    /* Items */
+    items = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/items/${params.collectionId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ItemsByOwner */
+    itemsByOwner = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/items_by_owner/${params.owner}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Collaborators */
+    collaborators = async (params) => {
+        const endpoint = `sparkdream/collect/v1/collaborators/${params.collectionId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Curator */
+    curator = async (params) => {
+        const endpoint = `sparkdream/collect/v1/curator/${params.address}`;
+        return await this.req.get(endpoint);
+    };
+    /* ActiveCurators */
+    activeCurators = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/active_curators`;
+        return await this.req.get(endpoint, options);
+    };
+    /* CurationSummary */
+    curationSummary = async (params) => {
+        const endpoint = `sparkdream/collect/v1/curation_summary/${params.collectionId}`;
+        return await this.req.get(endpoint);
+    };
+    /* CurationReviews */
+    curationReviews = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/curation_reviews/${params.collectionId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* CurationReviewsByCurator */
+    curationReviewsByCurator = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/curation_reviews_by_curator/${params.curator}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* SponsorshipRequest */
+    sponsorshipRequest = async (params) => {
+        const endpoint = `sparkdream/collect/v1/sponsorship_request/${params.collectionId}`;
+        return await this.req.get(endpoint);
+    };
+    /* SponsorshipRequests */
+    sponsorshipRequests = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/sponsorship_requests`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ContentFlag Queries a list of ContentFlag items. */
+    contentFlag = async (params) => {
+        const endpoint = `sparkdream/collect/v1/content_flag/${params.targetId}/${params.targetType}`;
+        return await this.req.get(endpoint);
+    };
+    /* FlaggedContent Queries a list of FlaggedContent items. */
+    flaggedContent = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/flagged_content`;
+        return await this.req.get(endpoint, options);
+    };
+    /* HideRecord Queries a list of HideRecord items. */
+    hideRecord = async (params) => {
+        const endpoint = `sparkdream/collect/v1/hide_record/${params.id}`;
+        return await this.req.get(endpoint);
+    };
+    /* HideRecordsByTarget Queries a list of HideRecordsByTarget items. */
+    hideRecordsByTarget = async (params) => {
+        const endpoint = `sparkdream/collect/v1/hide_records_by_target/${params.targetId}/${params.targetType}`;
+        return await this.req.get(endpoint);
+    };
+    /* PendingCollections Queries a list of PendingCollections items. */
+    pendingCollections = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/pending_collections`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Endorsement Queries a list of Endorsement items. */
+    endorsement = async (params) => {
+        const endpoint = `sparkdream/collect/v1/endorsement/${params.collectionId}`;
+        return await this.req.get(endpoint);
+    };
+    /* CollectionsByContent returns collections that reference a specific on-chain entity
+     (e.g., a blog post or forum thread) via OnChainReference items. */
+    collectionsByContent = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/collect/v1/collections_by_content/${params.module}/${params.entityType}/${params.entityId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* CollectionConviction returns the current conviction score, stake count, total staked,
+     and author bond for a collection (delegates to x/rep). */
+    collectionConviction = async (params) => {
+        const endpoint = `sparkdream/collect/v1/collection_conviction/${params.collectionId}`;
+        return await this.req.get(endpoint);
+    };
+}

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

@@ -0,0 +1,252 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryCollectionRequest, QueryCollectionResponse, QueryCollectionsByOwnerRequest, QueryCollectionsByOwnerResponse, QueryPublicCollectionsRequest, QueryPublicCollectionsResponse, QueryPublicCollectionsByTypeRequest, QueryPublicCollectionsByTypeResponse, QueryCollectionsByCollaboratorRequest, QueryCollectionsByCollaboratorResponse, QueryItemRequest, QueryItemResponse, QueryItemsRequest, QueryItemsResponse, QueryItemsByOwnerRequest, QueryItemsByOwnerResponse, QueryCollaboratorsRequest, QueryCollaboratorsResponse, QueryCuratorRequest, QueryCuratorResponse, QueryActiveCuratorsRequest, QueryActiveCuratorsResponse, QueryCurationSummaryRequest, QueryCurationSummaryResponse, QueryCurationReviewsRequest, QueryCurationReviewsResponse, QueryCurationReviewsByCuratorRequest, QueryCurationReviewsByCuratorResponse, QuerySponsorshipRequestRequest, QuerySponsorshipRequestResponse, QuerySponsorshipRequestsRequest, QuerySponsorshipRequestsResponse, QueryContentFlagRequest, QueryContentFlagResponse, QueryFlaggedContentRequest, QueryFlaggedContentResponse, QueryHideRecordRequest, QueryHideRecordResponse, QueryHideRecordsByTargetRequest, QueryHideRecordsByTargetResponse, QueryPendingCollectionsRequest, QueryPendingCollectionsResponse, QueryEndorsementRequest, QueryEndorsementResponse, QueryCollectionsByContentRequest, QueryCollectionsByContentResponse, QueryCollectionConvictionRequest, QueryCollectionConvictionResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Params */
+    params = async (request = {}) => {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* Collection */
+    collection = async (request) => {
+        const data = QueryCollectionRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Collection", data);
+        return promise.then(data => QueryCollectionResponse.decode(new BinaryReader(data)));
+    };
+    /* CollectionsByOwner */
+    collectionsByOwner = async (request) => {
+        const data = QueryCollectionsByOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CollectionsByOwner", data);
+        return promise.then(data => QueryCollectionsByOwnerResponse.decode(new BinaryReader(data)));
+    };
+    /* PublicCollections */
+    publicCollections = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryPublicCollectionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "PublicCollections", data);
+        return promise.then(data => QueryPublicCollectionsResponse.decode(new BinaryReader(data)));
+    };
+    /* PublicCollectionsByType */
+    publicCollectionsByType = async (request) => {
+        const data = QueryPublicCollectionsByTypeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "PublicCollectionsByType", data);
+        return promise.then(data => QueryPublicCollectionsByTypeResponse.decode(new BinaryReader(data)));
+    };
+    /* CollectionsByCollaborator */
+    collectionsByCollaborator = async (request) => {
+        const data = QueryCollectionsByCollaboratorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CollectionsByCollaborator", data);
+        return promise.then(data => QueryCollectionsByCollaboratorResponse.decode(new BinaryReader(data)));
+    };
+    /* Item */
+    item = async (request) => {
+        const data = QueryItemRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Item", data);
+        return promise.then(data => QueryItemResponse.decode(new BinaryReader(data)));
+    };
+    /* Items */
+    items = async (request) => {
+        const data = QueryItemsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Items", data);
+        return promise.then(data => QueryItemsResponse.decode(new BinaryReader(data)));
+    };
+    /* ItemsByOwner */
+    itemsByOwner = async (request) => {
+        const data = QueryItemsByOwnerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "ItemsByOwner", data);
+        return promise.then(data => QueryItemsByOwnerResponse.decode(new BinaryReader(data)));
+    };
+    /* Collaborators */
+    collaborators = async (request) => {
+        const data = QueryCollaboratorsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Collaborators", data);
+        return promise.then(data => QueryCollaboratorsResponse.decode(new BinaryReader(data)));
+    };
+    /* Curator */
+    curator = async (request) => {
+        const data = QueryCuratorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Curator", data);
+        return promise.then(data => QueryCuratorResponse.decode(new BinaryReader(data)));
+    };
+    /* ActiveCurators */
+    activeCurators = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryActiveCuratorsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "ActiveCurators", data);
+        return promise.then(data => QueryActiveCuratorsResponse.decode(new BinaryReader(data)));
+    };
+    /* CurationSummary */
+    curationSummary = async (request) => {
+        const data = QueryCurationSummaryRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CurationSummary", data);
+        return promise.then(data => QueryCurationSummaryResponse.decode(new BinaryReader(data)));
+    };
+    /* CurationReviews */
+    curationReviews = async (request) => {
+        const data = QueryCurationReviewsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CurationReviews", data);
+        return promise.then(data => QueryCurationReviewsResponse.decode(new BinaryReader(data)));
+    };
+    /* CurationReviewsByCurator */
+    curationReviewsByCurator = async (request) => {
+        const data = QueryCurationReviewsByCuratorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CurationReviewsByCurator", data);
+        return promise.then(data => QueryCurationReviewsByCuratorResponse.decode(new BinaryReader(data)));
+    };
+    /* SponsorshipRequest */
+    sponsorshipRequest = async (request) => {
+        const data = QuerySponsorshipRequestRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "SponsorshipRequest", data);
+        return promise.then(data => QuerySponsorshipRequestResponse.decode(new BinaryReader(data)));
+    };
+    /* SponsorshipRequests */
+    sponsorshipRequests = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QuerySponsorshipRequestsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "SponsorshipRequests", data);
+        return promise.then(data => QuerySponsorshipRequestsResponse.decode(new BinaryReader(data)));
+    };
+    /* ContentFlag Queries a list of ContentFlag items. */
+    contentFlag = async (request) => {
+        const data = QueryContentFlagRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "ContentFlag", data);
+        return promise.then(data => QueryContentFlagResponse.decode(new BinaryReader(data)));
+    };
+    /* FlaggedContent Queries a list of FlaggedContent items. */
+    flaggedContent = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryFlaggedContentRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "FlaggedContent", data);
+        return promise.then(data => QueryFlaggedContentResponse.decode(new BinaryReader(data)));
+    };
+    /* HideRecord Queries a list of HideRecord items. */
+    hideRecord = async (request) => {
+        const data = QueryHideRecordRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "HideRecord", data);
+        return promise.then(data => QueryHideRecordResponse.decode(new BinaryReader(data)));
+    };
+    /* HideRecordsByTarget Queries a list of HideRecordsByTarget items. */
+    hideRecordsByTarget = async (request) => {
+        const data = QueryHideRecordsByTargetRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "HideRecordsByTarget", data);
+        return promise.then(data => QueryHideRecordsByTargetResponse.decode(new BinaryReader(data)));
+    };
+    /* PendingCollections Queries a list of PendingCollections items. */
+    pendingCollections = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryPendingCollectionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "PendingCollections", data);
+        return promise.then(data => QueryPendingCollectionsResponse.decode(new BinaryReader(data)));
+    };
+    /* Endorsement Queries a list of Endorsement items. */
+    endorsement = async (request) => {
+        const data = QueryEndorsementRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "Endorsement", data);
+        return promise.then(data => QueryEndorsementResponse.decode(new BinaryReader(data)));
+    };
+    /* CollectionsByContent returns collections that reference a specific on-chain entity
+     (e.g., a blog post or forum thread) via OnChainReference items. */
+    collectionsByContent = async (request) => {
+        const data = QueryCollectionsByContentRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CollectionsByContent", data);
+        return promise.then(data => QueryCollectionsByContentResponse.decode(new BinaryReader(data)));
+    };
+    /* CollectionConviction returns the current conviction score, stake count, total staked,
+     and author bond for a collection (delegates to x/rep). */
+    collectionConviction = async (request) => {
+        const data = QueryCollectionConvictionRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.collect.v1.Query", "CollectionConviction", data);
+        return promise.then(data => QueryCollectionConvictionResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        collection(request) {
+            return queryService.collection(request);
+        },
+        collectionsByOwner(request) {
+            return queryService.collectionsByOwner(request);
+        },
+        publicCollections(request) {
+            return queryService.publicCollections(request);
+        },
+        publicCollectionsByType(request) {
+            return queryService.publicCollectionsByType(request);
+        },
+        collectionsByCollaborator(request) {
+            return queryService.collectionsByCollaborator(request);
+        },
+        item(request) {
+            return queryService.item(request);
+        },
+        items(request) {
+            return queryService.items(request);
+        },
+        itemsByOwner(request) {
+            return queryService.itemsByOwner(request);
+        },
+        collaborators(request) {
+            return queryService.collaborators(request);
+        },
+        curator(request) {
+            return queryService.curator(request);
+        },
+        activeCurators(request) {
+            return queryService.activeCurators(request);
+        },
+        curationSummary(request) {
+            return queryService.curationSummary(request);
+        },
+        curationReviews(request) {
+            return queryService.curationReviews(request);
+        },
+        curationReviewsByCurator(request) {
+            return queryService.curationReviewsByCurator(request);
+        },
+        sponsorshipRequest(request) {
+            return queryService.sponsorshipRequest(request);
+        },
+        sponsorshipRequests(request) {
+            return queryService.sponsorshipRequests(request);
+        },
+        contentFlag(request) {
+            return queryService.contentFlag(request);
+        },
+        flaggedContent(request) {
+            return queryService.flaggedContent(request);
+        },
+        hideRecord(request) {
+            return queryService.hideRecord(request);
+        },
+        hideRecordsByTarget(request) {
+            return queryService.hideRecordsByTarget(request);
+        },
+        pendingCollections(request) {
+            return queryService.pendingCollections(request);
+        },
+        endorsement(request) {
+            return queryService.endorsement(request);
+        },
+        collectionsByContent(request) {
+            return queryService.collectionsByContent(request);
+        },
+        collectionConviction(request) {
+            return queryService.collectionConviction(request);
+        }
+    };
+};

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

@@ -0,0 +1,149 @@
+//@ts-nocheck
+import { MsgUpdateParams, MsgCreateCollection, MsgUpdateCollection, MsgDeleteCollection, MsgAddItem, MsgAddItems, MsgUpdateItem, MsgRemoveItem, MsgRemoveItems, MsgReorderItem, MsgAddCollaborator, MsgRemoveCollaborator, MsgUpdateCollaboratorRole, MsgRegisterCurator, MsgUnregisterCurator, MsgRateCollection, MsgChallengeReview, MsgRequestSponsorship, MsgCancelSponsorshipRequest, MsgSponsorCollection, MsgUpdateOperationalParams, MsgUpvoteContent, MsgDownvoteContent, MsgFlagContent, MsgHideContent, MsgAppealHide, MsgEndorseCollection, MsgSetSeekingEndorsement, MsgPinCollection } from "./tx";
+export const AminoConverter = {
+    "/sparkdream.collect.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/collect/MsgUpdateParams",
+        toAmino: MsgUpdateParams.toAmino,
+        fromAmino: MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgCreateCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgCreateCollection",
+        toAmino: MsgCreateCollection.toAmino,
+        fromAmino: MsgCreateCollection.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgUpdateCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgUpdateCollection",
+        toAmino: MsgUpdateCollection.toAmino,
+        fromAmino: MsgUpdateCollection.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgDeleteCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgDeleteCollection",
+        toAmino: MsgDeleteCollection.toAmino,
+        fromAmino: MsgDeleteCollection.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgAddItem": {
+        aminoType: "/sparkdream.collect.v1.MsgAddItem",
+        toAmino: MsgAddItem.toAmino,
+        fromAmino: MsgAddItem.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgAddItems": {
+        aminoType: "/sparkdream.collect.v1.MsgAddItems",
+        toAmino: MsgAddItems.toAmino,
+        fromAmino: MsgAddItems.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgUpdateItem": {
+        aminoType: "/sparkdream.collect.v1.MsgUpdateItem",
+        toAmino: MsgUpdateItem.toAmino,
+        fromAmino: MsgUpdateItem.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgRemoveItem": {
+        aminoType: "/sparkdream.collect.v1.MsgRemoveItem",
+        toAmino: MsgRemoveItem.toAmino,
+        fromAmino: MsgRemoveItem.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgRemoveItems": {
+        aminoType: "/sparkdream.collect.v1.MsgRemoveItems",
+        toAmino: MsgRemoveItems.toAmino,
+        fromAmino: MsgRemoveItems.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgReorderItem": {
+        aminoType: "/sparkdream.collect.v1.MsgReorderItem",
+        toAmino: MsgReorderItem.toAmino,
+        fromAmino: MsgReorderItem.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgAddCollaborator": {
+        aminoType: "/sparkdream.collect.v1.MsgAddCollaborator",
+        toAmino: MsgAddCollaborator.toAmino,
+        fromAmino: MsgAddCollaborator.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgRemoveCollaborator": {
+        aminoType: "/sparkdream.collect.v1.MsgRemoveCollaborator",
+        toAmino: MsgRemoveCollaborator.toAmino,
+        fromAmino: MsgRemoveCollaborator.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgUpdateCollaboratorRole": {
+        aminoType: "/sparkdream.collect.v1.MsgUpdateCollaboratorRole",
+        toAmino: MsgUpdateCollaboratorRole.toAmino,
+        fromAmino: MsgUpdateCollaboratorRole.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgRegisterCurator": {
+        aminoType: "/sparkdream.collect.v1.MsgRegisterCurator",
+        toAmino: MsgRegisterCurator.toAmino,
+        fromAmino: MsgRegisterCurator.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgUnregisterCurator": {
+        aminoType: "/sparkdream.collect.v1.MsgUnregisterCurator",
+        toAmino: MsgUnregisterCurator.toAmino,
+        fromAmino: MsgUnregisterCurator.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgRateCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgRateCollection",
+        toAmino: MsgRateCollection.toAmino,
+        fromAmino: MsgRateCollection.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgChallengeReview": {
+        aminoType: "/sparkdream.collect.v1.MsgChallengeReview",
+        toAmino: MsgChallengeReview.toAmino,
+        fromAmino: MsgChallengeReview.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgRequestSponsorship": {
+        aminoType: "/sparkdream.collect.v1.MsgRequestSponsorship",
+        toAmino: MsgRequestSponsorship.toAmino,
+        fromAmino: MsgRequestSponsorship.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgCancelSponsorshipRequest": {
+        aminoType: "/sparkdream.collect.v1.MsgCancelSponsorshipRequest",
+        toAmino: MsgCancelSponsorshipRequest.toAmino,
+        fromAmino: MsgCancelSponsorshipRequest.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgSponsorCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgSponsorCollection",
+        toAmino: MsgSponsorCollection.toAmino,
+        fromAmino: MsgSponsorCollection.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgUpdateOperationalParams": {
+        aminoType: "sparkdream/x/collect/MsgUpdateOperationalParams",
+        toAmino: MsgUpdateOperationalParams.toAmino,
+        fromAmino: MsgUpdateOperationalParams.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgUpvoteContent": {
+        aminoType: "/sparkdream.collect.v1.MsgUpvoteContent",
+        toAmino: MsgUpvoteContent.toAmino,
+        fromAmino: MsgUpvoteContent.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgDownvoteContent": {
+        aminoType: "/sparkdream.collect.v1.MsgDownvoteContent",
+        toAmino: MsgDownvoteContent.toAmino,
+        fromAmino: MsgDownvoteContent.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgFlagContent": {
+        aminoType: "/sparkdream.collect.v1.MsgFlagContent",
+        toAmino: MsgFlagContent.toAmino,
+        fromAmino: MsgFlagContent.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgHideContent": {
+        aminoType: "/sparkdream.collect.v1.MsgHideContent",
+        toAmino: MsgHideContent.toAmino,
+        fromAmino: MsgHideContent.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgAppealHide": {
+        aminoType: "/sparkdream.collect.v1.MsgAppealHide",
+        toAmino: MsgAppealHide.toAmino,
+        fromAmino: MsgAppealHide.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgEndorseCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgEndorseCollection",
+        toAmino: MsgEndorseCollection.toAmino,
+        fromAmino: MsgEndorseCollection.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgSetSeekingEndorsement": {
+        aminoType: "/sparkdream.collect.v1.MsgSetSeekingEndorsement",
+        toAmino: MsgSetSeekingEndorsement.toAmino,
+        fromAmino: MsgSetSeekingEndorsement.fromAmino
+    },
+    "/sparkdream.collect.v1.MsgPinCollection": {
+        aminoType: "/sparkdream.collect.v1.MsgPinCollection",
+        toAmino: MsgPinCollection.toAmino,
+        fromAmino: MsgPinCollection.fromAmino
+    }
+};