@sparkdreamnft/sparkdreamjs 0.0.42 → 0.0.44

package/sparkdream/artifact/v1/genesis.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const types_1 = require("./types");
+const binary_1 = require("../../../binary");
+function createBaseGenesisState() {
+    return {
+        params: params_1.Params.fromPartial({}),
+        classSeq: BigInt(0),
+        hideSeq: BigInt(0),
+        classes: [],
+        tokens: [],
+        publicMintCounts: [],
+        receivePolicies: [],
+        pendingTransfers: [],
+        pendingMints: [],
+        listings: [],
+        pendingClassOwners: [],
+        hideRecords: [],
+        classCancelQueue: [],
+        classScrubQueue: [],
+        sentinelDailyHides: []
+    };
+}
+/**
+ * GenesisState defines the artifact module's genesis state. Derived indexes
+ * (owner indexes, inbox/outbox, counters, expiry indexes) are rebuilt on
+ * import and never exported.
+ * @name GenesisState
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.GenesisState
+ */
+exports.GenesisState = {
+    typeUrl: "/sparkdream.artifact.v1.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.classSeq !== BigInt(0)) {
+            writer.uint32(16).uint64(message.classSeq);
+        }
+        if (message.hideSeq !== BigInt(0)) {
+            writer.uint32(24).uint64(message.hideSeq);
+        }
+        for (const v of message.classes) {
+            types_1.Class.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.tokens) {
+            types_1.Token.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.publicMintCounts) {
+            types_1.PublicMintCountEntry.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.receivePolicies) {
+            types_1.ReceivePolicyEntry.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        for (const v of message.pendingTransfers) {
+            types_1.PendingTransfer.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        for (const v of message.pendingMints) {
+            types_1.PendingMint.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        for (const v of message.listings) {
+            types_1.Listing.encode(v, writer.uint32(82).fork()).ldelim();
+        }
+        for (const v of message.pendingClassOwners) {
+            types_1.PendingClassOwner.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        for (const v of message.hideRecords) {
+            types_1.HideRecord.encode(v, writer.uint32(98).fork()).ldelim();
+        }
+        for (const v of message.classCancelQueue) {
+            types_1.QueueCursor.encode(v, writer.uint32(106).fork()).ldelim();
+        }
+        for (const v of message.classScrubQueue) {
+            types_1.QueueCursor.encode(v, writer.uint32(114).fork()).ldelim();
+        }
+        for (const v of message.sentinelDailyHides) {
+            types_1.SentinelDailyHideEntry.encode(v, writer.uint32(122).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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_1.Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.classSeq = reader.uint64();
+                    break;
+                case 3:
+                    message.hideSeq = reader.uint64();
+                    break;
+                case 4:
+                    message.classes.push(types_1.Class.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.tokens.push(types_1.Token.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.publicMintCounts.push(types_1.PublicMintCountEntry.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.receivePolicies.push(types_1.ReceivePolicyEntry.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.pendingTransfers.push(types_1.PendingTransfer.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.pendingMints.push(types_1.PendingMint.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.listings.push(types_1.Listing.decode(reader, reader.uint32()));
+                    break;
+                case 11:
+                    message.pendingClassOwners.push(types_1.PendingClassOwner.decode(reader, reader.uint32()));
+                    break;
+                case 12:
+                    message.hideRecords.push(types_1.HideRecord.decode(reader, reader.uint32()));
+                    break;
+                case 13:
+                    message.classCancelQueue.push(types_1.QueueCursor.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.classScrubQueue.push(types_1.QueueCursor.decode(reader, reader.uint32()));
+                    break;
+                case 15:
+                    message.sentinelDailyHides.push(types_1.SentinelDailyHideEntry.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_1.Params.fromPartial(object.params) : undefined;
+        message.classSeq = object.classSeq !== undefined && object.classSeq !== null ? BigInt(object.classSeq.toString()) : BigInt(0);
+        message.hideSeq = object.hideSeq !== undefined && object.hideSeq !== null ? BigInt(object.hideSeq.toString()) : BigInt(0);
+        message.classes = object.classes?.map(e => types_1.Class.fromPartial(e)) || [];
+        message.tokens = object.tokens?.map(e => types_1.Token.fromPartial(e)) || [];
+        message.publicMintCounts = object.publicMintCounts?.map(e => types_1.PublicMintCountEntry.fromPartial(e)) || [];
+        message.receivePolicies = object.receivePolicies?.map(e => types_1.ReceivePolicyEntry.fromPartial(e)) || [];
+        message.pendingTransfers = object.pendingTransfers?.map(e => types_1.PendingTransfer.fromPartial(e)) || [];
+        message.pendingMints = object.pendingMints?.map(e => types_1.PendingMint.fromPartial(e)) || [];
+        message.listings = object.listings?.map(e => types_1.Listing.fromPartial(e)) || [];
+        message.pendingClassOwners = object.pendingClassOwners?.map(e => types_1.PendingClassOwner.fromPartial(e)) || [];
+        message.hideRecords = object.hideRecords?.map(e => types_1.HideRecord.fromPartial(e)) || [];
+        message.classCancelQueue = object.classCancelQueue?.map(e => types_1.QueueCursor.fromPartial(e)) || [];
+        message.classScrubQueue = object.classScrubQueue?.map(e => types_1.QueueCursor.fromPartial(e)) || [];
+        message.sentinelDailyHides = object.sentinelDailyHides?.map(e => types_1.SentinelDailyHideEntry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        if (object.class_seq !== undefined && object.class_seq !== null) {
+            message.classSeq = BigInt(object.class_seq);
+        }
+        if (object.hide_seq !== undefined && object.hide_seq !== null) {
+            message.hideSeq = BigInt(object.hide_seq);
+        }
+        message.classes = object.classes?.map(e => types_1.Class.fromAmino(e)) || [];
+        message.tokens = object.tokens?.map(e => types_1.Token.fromAmino(e)) || [];
+        message.publicMintCounts = object.public_mint_counts?.map(e => types_1.PublicMintCountEntry.fromAmino(e)) || [];
+        message.receivePolicies = object.receive_policies?.map(e => types_1.ReceivePolicyEntry.fromAmino(e)) || [];
+        message.pendingTransfers = object.pending_transfers?.map(e => types_1.PendingTransfer.fromAmino(e)) || [];
+        message.pendingMints = object.pending_mints?.map(e => types_1.PendingMint.fromAmino(e)) || [];
+        message.listings = object.listings?.map(e => types_1.Listing.fromAmino(e)) || [];
+        message.pendingClassOwners = object.pending_class_owners?.map(e => types_1.PendingClassOwner.fromAmino(e)) || [];
+        message.hideRecords = object.hide_records?.map(e => types_1.HideRecord.fromAmino(e)) || [];
+        message.classCancelQueue = object.class_cancel_queue?.map(e => types_1.QueueCursor.fromAmino(e)) || [];
+        message.classScrubQueue = object.class_scrub_queue?.map(e => types_1.QueueCursor.fromAmino(e)) || [];
+        message.sentinelDailyHides = object.sentinel_daily_hides?.map(e => types_1.SentinelDailyHideEntry.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : params_1.Params.toAmino(params_1.Params.fromPartial({}));
+        obj.class_seq = message.classSeq !== BigInt(0) ? message.classSeq?.toString() : undefined;
+        obj.hide_seq = message.hideSeq !== BigInt(0) ? message.hideSeq?.toString() : undefined;
+        if (message.classes) {
+            obj.classes = message.classes.map(e => e ? types_1.Class.toAmino(e) : undefined);
+        }
+        else {
+            obj.classes = message.classes;
+        }
+        if (message.tokens) {
+            obj.tokens = message.tokens.map(e => e ? types_1.Token.toAmino(e) : undefined);
+        }
+        else {
+            obj.tokens = message.tokens;
+        }
+        if (message.publicMintCounts) {
+            obj.public_mint_counts = message.publicMintCounts.map(e => e ? types_1.PublicMintCountEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.public_mint_counts = message.publicMintCounts;
+        }
+        if (message.receivePolicies) {
+            obj.receive_policies = message.receivePolicies.map(e => e ? types_1.ReceivePolicyEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.receive_policies = message.receivePolicies;
+        }
+        if (message.pendingTransfers) {
+            obj.pending_transfers = message.pendingTransfers.map(e => e ? types_1.PendingTransfer.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_transfers = message.pendingTransfers;
+        }
+        if (message.pendingMints) {
+            obj.pending_mints = message.pendingMints.map(e => e ? types_1.PendingMint.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_mints = message.pendingMints;
+        }
+        if (message.listings) {
+            obj.listings = message.listings.map(e => e ? types_1.Listing.toAmino(e) : undefined);
+        }
+        else {
+            obj.listings = message.listings;
+        }
+        if (message.pendingClassOwners) {
+            obj.pending_class_owners = message.pendingClassOwners.map(e => e ? types_1.PendingClassOwner.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_class_owners = message.pendingClassOwners;
+        }
+        if (message.hideRecords) {
+            obj.hide_records = message.hideRecords.map(e => e ? types_1.HideRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.hide_records = message.hideRecords;
+        }
+        if (message.classCancelQueue) {
+            obj.class_cancel_queue = message.classCancelQueue.map(e => e ? types_1.QueueCursor.toAmino(e) : undefined);
+        }
+        else {
+            obj.class_cancel_queue = message.classCancelQueue;
+        }
+        if (message.classScrubQueue) {
+            obj.class_scrub_queue = message.classScrubQueue.map(e => e ? types_1.QueueCursor.toAmino(e) : undefined);
+        }
+        else {
+            obj.class_scrub_queue = message.classScrubQueue;
+        }
+        if (message.sentinelDailyHides) {
+            obj.sentinel_daily_hides = message.sentinelDailyHides.map(e => e ? types_1.SentinelDailyHideEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.sentinel_daily_hides = message.sentinelDailyHides;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.artifact.v1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/sparkdream/artifact/v1/params.d.ts

@@ -0,0 +1,251 @@
+import { ReceivePolicy } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Params defines the parameters for the module. Fields 16-29 are the
+ * operational subset (ArtifactOperationalParams). Every field is clamped by
+ * the compiled hard bounds in x/artifact/types/params.go.
+ * @name Params
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Params
+ */
+export interface Params {
+    /**
+     * --- Gates (governance) ---
+     * Minimum x/rep trust level (TrustLevel enum value) to create a class.
+     */
+    minTrustLevelCreateClass: number;
+    maxClassesPerCreator: number;
+    defaultReceivePolicy: ReceivePolicy;
+    /**
+     * --- Size limits (governance) ---
+     */
+    maxNameLength: number;
+    maxSymbolLength: number;
+    maxDescriptionLength: number;
+    maxUriLength: number;
+    maxAttributes: number;
+    maxAttributeKeyLength: number;
+    maxAttributeValueLength: number;
+    maxMintersPerClass: number;
+    maxBatchSize: number;
+    allowedUriSchemes: string[];
+    /**
+     * --- Market bounds (governance) ---
+     */
+    maxRoyaltyBps: number;
+    saleFeeBps: number;
+    /**
+     * --- Operational ---
+     * SPARK burned on class creation.
+     */
+    classCreationFee: string;
+    /**
+     * SPARK held per token, refunded on burn/revoke.
+     */
+    tokenDeposit: string;
+    /**
+     * SPARK burned per inbox item created.
+     */
+    inboxFee: string;
+    /**
+     * Seconds an inbox item / class-owner proposal stays open.
+     */
+    pendingTtl: bigint;
+    /**
+     * Maximum listing duration in seconds.
+     */
+    maxListingDuration: bigint;
+    maxPendingPerPair: number;
+    maxInboxPerRecipient: number;
+    maxExpirationsPerBlock: number;
+    marketEnabled: boolean;
+    publicMintEnabled: boolean;
+    /**
+     * --- Moderation (operational; block heights) ---
+     */
+    maxHidesPerSentinelPerDay: number;
+    sentinelUnhideWindowBlocks: bigint;
+    hideExpiryBlocks: bigint;
+    /**
+     * DREAM reserved on the sentinel bond per hide.
+     */
+    sentinelHideCommitDream: string;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.Params";
+    value: Uint8Array;
+}
+/**
+ * Params defines the parameters for the module. Fields 16-29 are the
+ * operational subset (ArtifactOperationalParams). Every field is clamped by
+ * the compiled hard bounds in x/artifact/types/params.go.
+ * @name ParamsAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Params
+ */
+export interface ParamsAmino {
+    /**
+     * --- Gates (governance) ---
+     * Minimum x/rep trust level (TrustLevel enum value) to create a class.
+     */
+    min_trust_level_create_class?: number;
+    max_classes_per_creator?: number;
+    default_receive_policy?: ReceivePolicy;
+    /**
+     * --- Size limits (governance) ---
+     */
+    max_name_length?: number;
+    max_symbol_length?: number;
+    max_description_length?: number;
+    max_uri_length?: number;
+    max_attributes?: number;
+    max_attribute_key_length?: number;
+    max_attribute_value_length?: number;
+    max_minters_per_class?: number;
+    max_batch_size?: number;
+    allowed_uri_schemes?: string[];
+    /**
+     * --- Market bounds (governance) ---
+     */
+    max_royalty_bps?: number;
+    sale_fee_bps?: number;
+    /**
+     * --- Operational ---
+     * SPARK burned on class creation.
+     */
+    class_creation_fee?: string;
+    /**
+     * SPARK held per token, refunded on burn/revoke.
+     */
+    token_deposit?: string;
+    /**
+     * SPARK burned per inbox item created.
+     */
+    inbox_fee?: string;
+    /**
+     * Seconds an inbox item / class-owner proposal stays open.
+     */
+    pending_ttl?: string;
+    /**
+     * Maximum listing duration in seconds.
+     */
+    max_listing_duration?: string;
+    max_pending_per_pair?: number;
+    max_inbox_per_recipient?: number;
+    max_expirations_per_block?: number;
+    market_enabled?: boolean;
+    public_mint_enabled?: boolean;
+    /**
+     * --- Moderation (operational; block heights) ---
+     */
+    max_hides_per_sentinel_per_day?: number;
+    sentinel_unhide_window_blocks?: string;
+    hide_expiry_blocks?: string;
+    /**
+     * DREAM reserved on the sentinel bond per hide.
+     */
+    sentinel_hide_commit_dream?: string;
+}
+export interface ParamsAminoMsg {
+    type: "sparkdream/x/artifact/Params";
+    value: ParamsAmino;
+}
+/**
+ * ArtifactOperationalParams is the subset of Params the Commons Operations
+ * Committee may update (MsgUpdateOperationalParams). Full replacement: every
+ * field must be supplied.
+ * @name ArtifactOperationalParams
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ArtifactOperationalParams
+ */
+export interface ArtifactOperationalParams {
+    classCreationFee: string;
+    tokenDeposit: string;
+    inboxFee: string;
+    pendingTtl: bigint;
+    maxListingDuration: bigint;
+    maxPendingPerPair: number;
+    maxInboxPerRecipient: number;
+    maxExpirationsPerBlock: number;
+    marketEnabled: boolean;
+    publicMintEnabled: boolean;
+    maxHidesPerSentinelPerDay: number;
+    sentinelUnhideWindowBlocks: bigint;
+    hideExpiryBlocks: bigint;
+    sentinelHideCommitDream: string;
+}
+export interface ArtifactOperationalParamsProtoMsg {
+    typeUrl: "/sparkdream.artifact.v1.ArtifactOperationalParams";
+    value: Uint8Array;
+}
+/**
+ * ArtifactOperationalParams is the subset of Params the Commons Operations
+ * Committee may update (MsgUpdateOperationalParams). Full replacement: every
+ * field must be supplied.
+ * @name ArtifactOperationalParamsAmino
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ArtifactOperationalParams
+ */
+export interface ArtifactOperationalParamsAmino {
+    class_creation_fee?: string;
+    token_deposit?: string;
+    inbox_fee?: string;
+    pending_ttl?: string;
+    max_listing_duration?: string;
+    max_pending_per_pair?: number;
+    max_inbox_per_recipient?: number;
+    max_expirations_per_block?: number;
+    market_enabled?: boolean;
+    public_mint_enabled?: boolean;
+    max_hides_per_sentinel_per_day?: number;
+    sentinel_unhide_window_blocks?: string;
+    hide_expiry_blocks?: string;
+    sentinel_hide_commit_dream?: string;
+}
+export interface ArtifactOperationalParamsAminoMsg {
+    type: "/sparkdream.artifact.v1.ArtifactOperationalParams";
+    value: ArtifactOperationalParamsAmino;
+}
+/**
+ * Params defines the parameters for the module. Fields 16-29 are the
+ * operational subset (ArtifactOperationalParams). Every field is clamped by
+ * the compiled hard bounds in x/artifact/types/params.go.
+ * @name Params
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.Params
+ */
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    toAminoMsg(message: Params): ParamsAminoMsg;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};
+/**
+ * ArtifactOperationalParams is the subset of Params the Commons Operations
+ * Committee may update (MsgUpdateOperationalParams). Full replacement: every
+ * field must be supplied.
+ * @name ArtifactOperationalParams
+ * @package sparkdream.artifact.v1
+ * @see proto type: sparkdream.artifact.v1.ArtifactOperationalParams
+ */
+export declare const ArtifactOperationalParams: {
+    typeUrl: string;
+    encode(message: ArtifactOperationalParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ArtifactOperationalParams;
+    fromPartial(object: DeepPartial<ArtifactOperationalParams>): ArtifactOperationalParams;
+    fromAmino(object: ArtifactOperationalParamsAmino): ArtifactOperationalParams;
+    toAmino(message: ArtifactOperationalParams): ArtifactOperationalParamsAmino;
+    fromAminoMsg(object: ArtifactOperationalParamsAminoMsg): ArtifactOperationalParams;
+    fromProtoMsg(message: ArtifactOperationalParamsProtoMsg): ArtifactOperationalParams;
+    toProto(message: ArtifactOperationalParams): Uint8Array;
+    toProtoMsg(message: ArtifactOperationalParams): ArtifactOperationalParamsProtoMsg;
+};