@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/esm/sparkdream/collect/module/v1/module.js

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseModule() {
+    return {
+        authority: ""
+    };
+}
+/**
+ * Module is the config object for the module.
+ * @name Module
+ * @package sparkdream.collect.module.v1
+ * @see proto type: sparkdream.collect.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.collect.module.v1.Module",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseModule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseModule();
+        message.authority = object.authority ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModule();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Module.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Module.decode(message.value);
+    },
+    toProto(message) {
+        return Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/collect/v1/genesis.js

@@ -0,0 +1,271 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { Collection, Item, Collaborator, Curator, CurationReview, CurationSummary, SponsorshipRequest, CollectionFlag, HideRecord, Endorsement } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({}),
+        collections: [],
+        collectionCount: BigInt(0),
+        items: [],
+        itemCount: BigInt(0),
+        collaborators: [],
+        curators: [],
+        curationReviews: [],
+        curationReviewCount: BigInt(0),
+        curationSummaries: [],
+        sponsorshipRequests: [],
+        flags: [],
+        hideRecords: [],
+        hideRecordCount: BigInt(0),
+        endorsements: []
+    };
+}
+/**
+ * GenesisState defines the collect module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/sparkdream.collect.v1.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.collections) {
+            Collection.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.collectionCount !== BigInt(0)) {
+            writer.uint32(24).uint64(message.collectionCount);
+        }
+        for (const v of message.items) {
+            Item.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.itemCount !== BigInt(0)) {
+            writer.uint32(40).uint64(message.itemCount);
+        }
+        for (const v of message.collaborators) {
+            Collaborator.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.curators) {
+            Curator.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        for (const v of message.curationReviews) {
+            CurationReview.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.curationReviewCount !== BigInt(0)) {
+            writer.uint32(72).uint64(message.curationReviewCount);
+        }
+        for (const v of message.curationSummaries) {
+            CurationSummary.encode(v, writer.uint32(82).fork()).ldelim();
+        }
+        for (const v of message.sponsorshipRequests) {
+            SponsorshipRequest.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        for (const v of message.flags) {
+            CollectionFlag.encode(v, writer.uint32(98).fork()).ldelim();
+        }
+        for (const v of message.hideRecords) {
+            HideRecord.encode(v, writer.uint32(106).fork()).ldelim();
+        }
+        if (message.hideRecordCount !== BigInt(0)) {
+            writer.uint32(112).uint64(message.hideRecordCount);
+        }
+        for (const v of message.endorsements) {
+            Endorsement.encode(v, writer.uint32(122).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.collectionCount = reader.uint64();
+                    break;
+                case 4:
+                    message.items.push(Item.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.itemCount = reader.uint64();
+                    break;
+                case 6:
+                    message.collaborators.push(Collaborator.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.curators.push(Curator.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.curationReviews.push(CurationReview.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.curationReviewCount = reader.uint64();
+                    break;
+                case 10:
+                    message.curationSummaries.push(CurationSummary.decode(reader, reader.uint32()));
+                    break;
+                case 11:
+                    message.sponsorshipRequests.push(SponsorshipRequest.decode(reader, reader.uint32()));
+                    break;
+                case 12:
+                    message.flags.push(CollectionFlag.decode(reader, reader.uint32()));
+                    break;
+                case 13:
+                    message.hideRecords.push(HideRecord.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.hideRecordCount = reader.uint64();
+                    break;
+                case 15:
+                    message.endorsements.push(Endorsement.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.collectionCount = object.collectionCount !== undefined && object.collectionCount !== null ? BigInt(object.collectionCount.toString()) : BigInt(0);
+        message.items = object.items?.map(e => Item.fromPartial(e)) || [];
+        message.itemCount = object.itemCount !== undefined && object.itemCount !== null ? BigInt(object.itemCount.toString()) : BigInt(0);
+        message.collaborators = object.collaborators?.map(e => Collaborator.fromPartial(e)) || [];
+        message.curators = object.curators?.map(e => Curator.fromPartial(e)) || [];
+        message.curationReviews = object.curationReviews?.map(e => CurationReview.fromPartial(e)) || [];
+        message.curationReviewCount = object.curationReviewCount !== undefined && object.curationReviewCount !== null ? BigInt(object.curationReviewCount.toString()) : BigInt(0);
+        message.curationSummaries = object.curationSummaries?.map(e => CurationSummary.fromPartial(e)) || [];
+        message.sponsorshipRequests = object.sponsorshipRequests?.map(e => SponsorshipRequest.fromPartial(e)) || [];
+        message.flags = object.flags?.map(e => CollectionFlag.fromPartial(e)) || [];
+        message.hideRecords = object.hideRecords?.map(e => HideRecord.fromPartial(e)) || [];
+        message.hideRecordCount = object.hideRecordCount !== undefined && object.hideRecordCount !== null ? BigInt(object.hideRecordCount.toString()) : BigInt(0);
+        message.endorsements = object.endorsements?.map(e => Endorsement.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.collection_count !== undefined && object.collection_count !== null) {
+            message.collectionCount = BigInt(object.collection_count);
+        }
+        message.items = object.items?.map(e => Item.fromAmino(e)) || [];
+        if (object.item_count !== undefined && object.item_count !== null) {
+            message.itemCount = BigInt(object.item_count);
+        }
+        message.collaborators = object.collaborators?.map(e => Collaborator.fromAmino(e)) || [];
+        message.curators = object.curators?.map(e => Curator.fromAmino(e)) || [];
+        message.curationReviews = object.curation_reviews?.map(e => CurationReview.fromAmino(e)) || [];
+        if (object.curation_review_count !== undefined && object.curation_review_count !== null) {
+            message.curationReviewCount = BigInt(object.curation_review_count);
+        }
+        message.curationSummaries = object.curation_summaries?.map(e => CurationSummary.fromAmino(e)) || [];
+        message.sponsorshipRequests = object.sponsorship_requests?.map(e => SponsorshipRequest.fromAmino(e)) || [];
+        message.flags = object.flags?.map(e => CollectionFlag.fromAmino(e)) || [];
+        message.hideRecords = object.hide_records?.map(e => HideRecord.fromAmino(e)) || [];
+        if (object.hide_record_count !== undefined && object.hide_record_count !== null) {
+            message.hideRecordCount = BigInt(object.hide_record_count);
+        }
+        message.endorsements = object.endorsements?.map(e => Endorsement.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.collection_count = message.collectionCount !== BigInt(0) ? message.collectionCount?.toString() : undefined;
+        if (message.items) {
+            obj.items = message.items.map(e => e ? Item.toAmino(e) : undefined);
+        }
+        else {
+            obj.items = message.items;
+        }
+        obj.item_count = message.itemCount !== BigInt(0) ? message.itemCount?.toString() : undefined;
+        if (message.collaborators) {
+            obj.collaborators = message.collaborators.map(e => e ? Collaborator.toAmino(e) : undefined);
+        }
+        else {
+            obj.collaborators = message.collaborators;
+        }
+        if (message.curators) {
+            obj.curators = message.curators.map(e => e ? Curator.toAmino(e) : undefined);
+        }
+        else {
+            obj.curators = message.curators;
+        }
+        if (message.curationReviews) {
+            obj.curation_reviews = message.curationReviews.map(e => e ? CurationReview.toAmino(e) : undefined);
+        }
+        else {
+            obj.curation_reviews = message.curationReviews;
+        }
+        obj.curation_review_count = message.curationReviewCount !== BigInt(0) ? message.curationReviewCount?.toString() : undefined;
+        if (message.curationSummaries) {
+            obj.curation_summaries = message.curationSummaries.map(e => e ? CurationSummary.toAmino(e) : undefined);
+        }
+        else {
+            obj.curation_summaries = message.curationSummaries;
+        }
+        if (message.sponsorshipRequests) {
+            obj.sponsorship_requests = message.sponsorshipRequests.map(e => e ? SponsorshipRequest.toAmino(e) : undefined);
+        }
+        else {
+            obj.sponsorship_requests = message.sponsorshipRequests;
+        }
+        if (message.flags) {
+            obj.flags = message.flags.map(e => e ? CollectionFlag.toAmino(e) : undefined);
+        }
+        else {
+            obj.flags = message.flags;
+        }
+        if (message.hideRecords) {
+            obj.hide_records = message.hideRecords.map(e => e ? HideRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.hide_records = message.hideRecords;
+        }
+        obj.hide_record_count = message.hideRecordCount !== BigInt(0) ? message.hideRecordCount?.toString() : undefined;
+        if (message.endorsements) {
+            obj.endorsements = message.endorsements.map(e => e ? Endorsement.toAmino(e) : undefined);
+        }
+        else {
+            obj.endorsements = message.endorsements;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};