@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/sparkdream/name/v1/genesis.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const name_record_1 = require("./name_record");
+const owner_info_1 = require("./owner_info");
+const dispute_1 = require("./dispute");
+const binary_1 = require("../../../binary");
+function createBaseGenesisState() {
+    return {
+        params: params_1.Params.fromPartial({}),
+        nameRecords: [],
+        ownerInfos: [],
+        disputeMap: []
+    };
+}
+/**
+ * GenesisState defines the name module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.GenesisState
+ */
+exports.GenesisState = {
+    typeUrl: "/sparkdream.name.v1.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.nameRecords) {
+            name_record_1.NameRecord.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.ownerInfos) {
+            owner_info_1.OwnerInfo.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.disputeMap) {
+            dispute_1.Dispute.encode(v, writer.uint32(34).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.nameRecords.push(name_record_1.NameRecord.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.ownerInfos.push(owner_info_1.OwnerInfo.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.disputeMap.push(dispute_1.Dispute.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.nameRecords = object.nameRecords?.map(e => name_record_1.NameRecord.fromPartial(e)) || [];
+        message.ownerInfos = object.ownerInfos?.map(e => owner_info_1.OwnerInfo.fromPartial(e)) || [];
+        message.disputeMap = object.disputeMap?.map(e => dispute_1.Dispute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        message.nameRecords = object.name_records?.map(e => name_record_1.NameRecord.fromAmino(e)) || [];
+        message.ownerInfos = object.owner_infos?.map(e => owner_info_1.OwnerInfo.fromAmino(e)) || [];
+        message.disputeMap = object.dispute_map?.map(e => dispute_1.Dispute.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({}));
+        if (message.nameRecords) {
+            obj.name_records = message.nameRecords.map(e => e ? name_record_1.NameRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.name_records = message.nameRecords;
+        }
+        if (message.ownerInfos) {
+            obj.owner_infos = message.ownerInfos.map(e => e ? owner_info_1.OwnerInfo.toAmino(e) : undefined);
+        }
+        else {
+            obj.owner_infos = message.ownerInfos;
+        }
+        if (message.disputeMap) {
+            obj.dispute_map = message.disputeMap.map(e => e ? dispute_1.Dispute.toAmino(e) : undefined);
+        }
+        else {
+            obj.dispute_map = message.disputeMap;
+        }
+        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.name.v1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/sparkdream/name/v1/name_record.d.ts

@@ -0,0 +1,50 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * NameRecord defines the NameRecord message.
+ * @name NameRecord
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameRecord
+ */
+export interface NameRecord {
+    name: string;
+    owner: string;
+    data: string;
+}
+export interface NameRecordProtoMsg {
+    typeUrl: "/sparkdream.name.v1.NameRecord";
+    value: Uint8Array;
+}
+/**
+ * NameRecord defines the NameRecord message.
+ * @name NameRecordAmino
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameRecord
+ */
+export interface NameRecordAmino {
+    name?: string;
+    owner?: string;
+    data?: string;
+}
+export interface NameRecordAminoMsg {
+    type: "/sparkdream.name.v1.NameRecord";
+    value: NameRecordAmino;
+}
+/**
+ * NameRecord defines the NameRecord message.
+ * @name NameRecord
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameRecord
+ */
+export declare const NameRecord: {
+    typeUrl: string;
+    encode(message: NameRecord, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): NameRecord;
+    fromPartial(object: DeepPartial<NameRecord>): NameRecord;
+    fromAmino(object: NameRecordAmino): NameRecord;
+    toAmino(message: NameRecord): NameRecordAmino;
+    fromAminoMsg(object: NameRecordAminoMsg): NameRecord;
+    fromProtoMsg(message: NameRecordProtoMsg): NameRecord;
+    toProto(message: NameRecord): Uint8Array;
+    toProtoMsg(message: NameRecord): NameRecordProtoMsg;
+};

package/sparkdream/name/v1/name_record.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameRecord = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseNameRecord() {
+    return {
+        name: "",
+        owner: "",
+        data: ""
+    };
+}
+/**
+ * NameRecord defines the NameRecord message.
+ * @name NameRecord
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameRecord
+ */
+exports.NameRecord = {
+    typeUrl: "/sparkdream.name.v1.NameRecord",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.owner !== "") {
+            writer.uint32(18).string(message.owner);
+        }
+        if (message.data !== "") {
+            writer.uint32(26).string(message.data);
+        }
+        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 = createBaseNameRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.owner = reader.string();
+                    break;
+                case 3:
+                    message.data = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseNameRecord();
+        message.name = object.name ?? "";
+        message.owner = object.owner ?? "";
+        message.data = object.data ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseNameRecord();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = object.data;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.owner = message.owner === "" ? undefined : message.owner;
+        obj.data = message.data === "" ? undefined : message.data;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.NameRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.NameRecord.decode(message.value);
+    },
+    toProto(message) {
+        return exports.NameRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.name.v1.NameRecord",
+            value: exports.NameRecord.encode(message).finish()
+        };
+    }
+};

package/sparkdream/name/v1/owner_info.d.ts

@@ -0,0 +1,50 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * OwnerInfo defines the OwnerInfo message.
+ * @name OwnerInfo
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.OwnerInfo
+ */
+export interface OwnerInfo {
+    address: string;
+    primaryName: string;
+    lastActiveTime: bigint;
+}
+export interface OwnerInfoProtoMsg {
+    typeUrl: "/sparkdream.name.v1.OwnerInfo";
+    value: Uint8Array;
+}
+/**
+ * OwnerInfo defines the OwnerInfo message.
+ * @name OwnerInfoAmino
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.OwnerInfo
+ */
+export interface OwnerInfoAmino {
+    address?: string;
+    primary_name?: string;
+    last_active_time?: string;
+}
+export interface OwnerInfoAminoMsg {
+    type: "/sparkdream.name.v1.OwnerInfo";
+    value: OwnerInfoAmino;
+}
+/**
+ * OwnerInfo defines the OwnerInfo message.
+ * @name OwnerInfo
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.OwnerInfo
+ */
+export declare const OwnerInfo: {
+    typeUrl: string;
+    encode(message: OwnerInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OwnerInfo;
+    fromPartial(object: DeepPartial<OwnerInfo>): OwnerInfo;
+    fromAmino(object: OwnerInfoAmino): OwnerInfo;
+    toAmino(message: OwnerInfo): OwnerInfoAmino;
+    fromAminoMsg(object: OwnerInfoAminoMsg): OwnerInfo;
+    fromProtoMsg(message: OwnerInfoProtoMsg): OwnerInfo;
+    toProto(message: OwnerInfo): Uint8Array;
+    toProtoMsg(message: OwnerInfo): OwnerInfoProtoMsg;
+};

package/sparkdream/name/v1/owner_info.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerInfo = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseOwnerInfo() {
+    return {
+        address: "",
+        primaryName: "",
+        lastActiveTime: BigInt(0)
+    };
+}
+/**
+ * OwnerInfo defines the OwnerInfo message.
+ * @name OwnerInfo
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.OwnerInfo
+ */
+exports.OwnerInfo = {
+    typeUrl: "/sparkdream.name.v1.OwnerInfo",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.primaryName !== "") {
+            writer.uint32(18).string(message.primaryName);
+        }
+        if (message.lastActiveTime !== BigInt(0)) {
+            writer.uint32(24).int64(message.lastActiveTime);
+        }
+        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 = createBaseOwnerInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.primaryName = reader.string();
+                    break;
+                case 3:
+                    message.lastActiveTime = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseOwnerInfo();
+        message.address = object.address ?? "";
+        message.primaryName = object.primaryName ?? "";
+        message.lastActiveTime = object.lastActiveTime !== undefined && object.lastActiveTime !== null ? BigInt(object.lastActiveTime.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseOwnerInfo();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.primary_name !== undefined && object.primary_name !== null) {
+            message.primaryName = object.primary_name;
+        }
+        if (object.last_active_time !== undefined && object.last_active_time !== null) {
+            message.lastActiveTime = BigInt(object.last_active_time);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.primary_name = message.primaryName === "" ? undefined : message.primaryName;
+        obj.last_active_time = message.lastActiveTime !== BigInt(0) ? message.lastActiveTime?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.OwnerInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.OwnerInfo.decode(message.value);
+    },
+    toProto(message) {
+        return exports.OwnerInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.name.v1.OwnerInfo",
+            value: exports.OwnerInfo.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,165 @@
+import { Duration, DurationAmino } from "../../../google/protobuf/duration";
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Params defines the parameters for the module.
+ * @name Params
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.Params
+ */
+export interface Params {
+    blockedNames: string[];
+    minNameLength: bigint;
+    maxNameLength: bigint;
+    maxNamesPerAddress: bigint;
+    expirationDuration: Duration;
+    registrationFee: Coin;
+    /**
+     * DREAM tokens staked by claimant when filing a dispute (default 50)
+     */
+    disputeStakeDream: string;
+    /**
+     * Blocks before an uncontested dispute auto-resolves (~7 days = 100800)
+     */
+    disputeTimeoutBlocks: bigint;
+    /**
+     * DREAM tokens staked by owner when contesting a dispute (default 100)
+     */
+    contestStakeDream: string;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/sparkdream.name.v1.Params";
+    value: Uint8Array;
+}
+/**
+ * Params defines the parameters for the module.
+ * @name ParamsAmino
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.Params
+ */
+export interface ParamsAmino {
+    blocked_names?: string[];
+    min_name_length?: string;
+    max_name_length?: string;
+    max_names_per_address?: string;
+    expiration_duration?: DurationAmino;
+    registration_fee: CoinAmino;
+    /**
+     * DREAM tokens staked by claimant when filing a dispute (default 50)
+     */
+    dispute_stake_dream?: string;
+    /**
+     * Blocks before an uncontested dispute auto-resolves (~7 days = 100800)
+     */
+    dispute_timeout_blocks?: string;
+    /**
+     * DREAM tokens staked by owner when contesting a dispute (default 100)
+     */
+    contest_stake_dream?: string;
+}
+export interface ParamsAminoMsg {
+    type: "sparkdream/x/name/Params";
+    value: ParamsAmino;
+}
+/**
+ * NameOperationalParams defines the operational parameters that can be updated
+ * by the Commons Council Operations Committee without a full governance proposal.
+ * Governance-only fields (blocked_names, min_name_length, max_name_length,
+ * max_names_per_address) are excluded and can only be changed via MsgUpdateParams.
+ * @name NameOperationalParams
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameOperationalParams
+ */
+export interface NameOperationalParams {
+    expirationDuration: Duration;
+    registrationFee: Coin;
+    /**
+     * DREAM tokens staked by claimant when filing a dispute (default 50)
+     */
+    disputeStakeDream: string;
+    /**
+     * Blocks before an uncontested dispute auto-resolves (~7 days = 100800)
+     */
+    disputeTimeoutBlocks: bigint;
+    /**
+     * DREAM tokens staked by owner when contesting a dispute (default 100)
+     */
+    contestStakeDream: string;
+}
+export interface NameOperationalParamsProtoMsg {
+    typeUrl: "/sparkdream.name.v1.NameOperationalParams";
+    value: Uint8Array;
+}
+/**
+ * NameOperationalParams defines the operational parameters that can be updated
+ * by the Commons Council Operations Committee without a full governance proposal.
+ * Governance-only fields (blocked_names, min_name_length, max_name_length,
+ * max_names_per_address) are excluded and can only be changed via MsgUpdateParams.
+ * @name NameOperationalParamsAmino
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameOperationalParams
+ */
+export interface NameOperationalParamsAmino {
+    expiration_duration?: DurationAmino;
+    registration_fee: CoinAmino;
+    /**
+     * DREAM tokens staked by claimant when filing a dispute (default 50)
+     */
+    dispute_stake_dream?: string;
+    /**
+     * Blocks before an uncontested dispute auto-resolves (~7 days = 100800)
+     */
+    dispute_timeout_blocks?: string;
+    /**
+     * DREAM tokens staked by owner when contesting a dispute (default 100)
+     */
+    contest_stake_dream?: string;
+}
+export interface NameOperationalParamsAminoMsg {
+    type: "sparkdream/x/name/NameOperationalParams";
+    value: NameOperationalParamsAmino;
+}
+/**
+ * Params defines the parameters for the module.
+ * @name Params
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.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;
+};
+/**
+ * NameOperationalParams defines the operational parameters that can be updated
+ * by the Commons Council Operations Committee without a full governance proposal.
+ * Governance-only fields (blocked_names, min_name_length, max_name_length,
+ * max_names_per_address) are excluded and can only be changed via MsgUpdateParams.
+ * @name NameOperationalParams
+ * @package sparkdream.name.v1
+ * @see proto type: sparkdream.name.v1.NameOperationalParams
+ */
+export declare const NameOperationalParams: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: NameOperationalParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): NameOperationalParams;
+    fromPartial(object: DeepPartial<NameOperationalParams>): NameOperationalParams;
+    fromAmino(object: NameOperationalParamsAmino): NameOperationalParams;
+    toAmino(message: NameOperationalParams): NameOperationalParamsAmino;
+    fromAminoMsg(object: NameOperationalParamsAminoMsg): NameOperationalParams;
+    toAminoMsg(message: NameOperationalParams): NameOperationalParamsAminoMsg;
+    fromProtoMsg(message: NameOperationalParamsProtoMsg): NameOperationalParams;
+    toProto(message: NameOperationalParams): Uint8Array;
+    toProtoMsg(message: NameOperationalParams): NameOperationalParamsProtoMsg;
+};