@sparkdreamnft/sparkdreamjs 0.0.16 → 0.0.18

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

@@ -1,54 +1,75 @@
 //@ts-nocheck
-import { MsgUpdateParams, MsgPropose, MsgApprove, MsgReject, MsgStake, MsgWithdraw, MsgReveal, MsgVerify, MsgCancel, MsgResolveDispute } from "./tx";
+// HAND-WRITTEN OVERRIDE — overlaid by scripts/codegen.ts after telescope.
+// See ../../commons/v1/tx.amino.ts for the broader rationale.
+//
+// MsgPropose has `repeated TrancheDef tranches` which Telescope emits as `[]`
+// when empty — fine for a normal proposal but the override still mirrors
+// aminojson's omitempty so the JS-signed bytes match the chain's reconstruction
+// for any edge case (e.g. a single-tranche proposal where the contributor
+// passes `[]` then computes tranches server-side).
+import { MsgUpdateParams, MsgPropose, MsgApprove, MsgReject, MsgStake, MsgWithdraw, MsgReveal, MsgVerify, MsgCancel, MsgResolveDispute, } from "./tx";
+import { TrancheDef } from "./types";
 export const AminoConverter = {
     "/sparkdream.reveal.v1.MsgUpdateParams": {
         aminoType: "sparkdream/x/reveal/MsgUpdateParams",
         toAmino: MsgUpdateParams.toAmino,
-        fromAmino: MsgUpdateParams.fromAmino
+        fromAmino: MsgUpdateParams.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgPropose": {
         aminoType: "sparkdream/x/reveal/MsgPropose",
-        toAmino: MsgPropose.toAmino,
-        fromAmino: MsgPropose.fromAmino
+        toAmino(message) {
+            const obj = {};
+            obj.contributor = message.contributor === "" ? undefined : message.contributor;
+            obj.project_name = message.projectName === "" ? undefined : message.projectName;
+            obj.description = message.description === "" ? undefined : message.description;
+            obj.total_valuation = message.totalValuation === "" ? undefined : message.totalValuation;
+            obj.tranches = (message.tranches?.length ?? 0) > 0
+                ? message.tranches.map((e) => e ? TrancheDef.toAmino(e) : undefined)
+                : undefined;
+            obj.initial_license = message.initialLicense === "" ? undefined : message.initialLicense;
+            obj.final_license = message.finalLicense === "" ? undefined : message.finalLicense;
+            return obj;
+        },
+        fromAmino: MsgPropose.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgApprove": {
         aminoType: "sparkdream/x/reveal/MsgApprove",
         toAmino: MsgApprove.toAmino,
-        fromAmino: MsgApprove.fromAmino
+        fromAmino: MsgApprove.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgReject": {
         aminoType: "sparkdream/x/reveal/MsgReject",
         toAmino: MsgReject.toAmino,
-        fromAmino: MsgReject.fromAmino
+        fromAmino: MsgReject.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgStake": {
         aminoType: "sparkdream/x/reveal/MsgStake",
         toAmino: MsgStake.toAmino,
-        fromAmino: MsgStake.fromAmino
+        fromAmino: MsgStake.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgWithdraw": {
         aminoType: "sparkdream/x/reveal/MsgWithdraw",
         toAmino: MsgWithdraw.toAmino,
-        fromAmino: MsgWithdraw.fromAmino
+        fromAmino: MsgWithdraw.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgReveal": {
         aminoType: "sparkdream/x/reveal/MsgReveal",
         toAmino: MsgReveal.toAmino,
-        fromAmino: MsgReveal.fromAmino
+        fromAmino: MsgReveal.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgVerify": {
         aminoType: "sparkdream/x/reveal/MsgVerify",
         toAmino: MsgVerify.toAmino,
-        fromAmino: MsgVerify.fromAmino
+        fromAmino: MsgVerify.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgCancel": {
         aminoType: "sparkdream/x/reveal/MsgCancel",
         toAmino: MsgCancel.toAmino,
-        fromAmino: MsgCancel.fromAmino
+        fromAmino: MsgCancel.fromAmino,
     },
     "/sparkdream.reveal.v1.MsgResolveDispute": {
         aminoType: "sparkdream/x/reveal/MsgResolveDispute",
         toAmino: MsgResolveDispute.toAmino,
-        fromAmino: MsgResolveDispute.fromAmino
-    }
+        fromAmino: MsgResolveDispute.fromAmino,
+    },
 };

package/esm/sparkdream/rpc.query.js

@@ -86,6 +86,12 @@ export const createRPCQueryClient = async ({ rpcEndpoint }) => {
             futarchy: {
                 v1: (await import("./futarchy/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },
+            guardian: {
+                v1: (await import("./guardian/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            identity: {
+                v1: (await import("./identity/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
             name: {
                 v1: (await import("./name/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },
@@ -98,6 +104,9 @@ export const createRPCQueryClient = async ({ rpcEndpoint }) => {
             season: {
                 v1: (await import("./season/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },
+            service: {
+                v1: (await import("./service/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
             session: {
                 v1: (await import("./session/v1/query.rpc.Query")).createRpcQueryExtension(client)
             },

package/esm/sparkdream/rpc.tx.js

@@ -72,6 +72,9 @@ export const createRPCMsgClient = async ({ rpc }) => ({
         futarchy: {
             v1: new (await import("./futarchy/v1/tx.rpc.msg")).MsgClientImpl(rpc)
         },
+        guardian: {
+            v1: new (await import("./guardian/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
         name: {
             v1: new (await import("./name/v1/tx.rpc.msg")).MsgClientImpl(rpc)
         },
@@ -84,6 +87,9 @@ export const createRPCMsgClient = async ({ rpc }) => ({
         season: {
             v1: new (await import("./season/v1/tx.rpc.msg")).MsgClientImpl(rpc)
         },
+        service: {
+            v1: new (await import("./service/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
         session: {
             v1: new (await import("./session/v1/tx.rpc.msg")).MsgClientImpl(rpc)
         },

package/esm/sparkdream/service/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.service.module.v1
+ * @see proto type: sparkdream.service.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.service.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.service.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/service/v1/controller_transfer_case.js

@@ -0,0 +1,155 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseControllerTransferCase() {
+    return {
+        juryCaseId: BigInt(0),
+        operatorAddress: "",
+        serviceType: "",
+        opener: "",
+        proposedNewController: "",
+        deposit: "",
+        openedAt: BigInt(0)
+    };
+}
+/**
+ * ControllerTransferCase records an open jury case to transfer an
+ * operator's controller (see x-service-spec.md §5.4). Created by
+ * MsgOpenControllerTransferCase, deleted by MsgFinalizeControllerTransfer.
+ *
+ * At most one open case per (operator_address, service_type), enforced
+ * via OpenControllerTransferByOperator secondary index.
+ * @name ControllerTransferCase
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.ControllerTransferCase
+ */
+export const ControllerTransferCase = {
+    typeUrl: "/sparkdream.service.v1.ControllerTransferCase",
+    aminoType: "sparkdream/x/service/ControllerTransferCase",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.juryCaseId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.juryCaseId);
+        }
+        if (message.operatorAddress !== "") {
+            writer.uint32(18).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        if (message.opener !== "") {
+            writer.uint32(34).string(message.opener);
+        }
+        if (message.proposedNewController !== "") {
+            writer.uint32(42).string(message.proposedNewController);
+        }
+        if (message.deposit !== "") {
+            writer.uint32(50).string(message.deposit);
+        }
+        if (message.openedAt !== BigInt(0)) {
+            writer.uint32(56).int64(message.openedAt);
+        }
+        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 = createBaseControllerTransferCase();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.juryCaseId = reader.uint64();
+                    break;
+                case 2:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    message.opener = reader.string();
+                    break;
+                case 5:
+                    message.proposedNewController = reader.string();
+                    break;
+                case 6:
+                    message.deposit = reader.string();
+                    break;
+                case 7:
+                    message.openedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseControllerTransferCase();
+        message.juryCaseId = object.juryCaseId !== undefined && object.juryCaseId !== null ? BigInt(object.juryCaseId.toString()) : BigInt(0);
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.opener = object.opener ?? "";
+        message.proposedNewController = object.proposedNewController ?? "";
+        message.deposit = object.deposit ?? "";
+        message.openedAt = object.openedAt !== undefined && object.openedAt !== null ? BigInt(object.openedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseControllerTransferCase();
+        if (object.jury_case_id !== undefined && object.jury_case_id !== null) {
+            message.juryCaseId = BigInt(object.jury_case_id);
+        }
+        if (object.operator_address !== undefined && object.operator_address !== null) {
+            message.operatorAddress = object.operator_address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.opener !== undefined && object.opener !== null) {
+            message.opener = object.opener;
+        }
+        if (object.proposed_new_controller !== undefined && object.proposed_new_controller !== null) {
+            message.proposedNewController = object.proposed_new_controller;
+        }
+        if (object.deposit !== undefined && object.deposit !== null) {
+            message.deposit = object.deposit;
+        }
+        if (object.opened_at !== undefined && object.opened_at !== null) {
+            message.openedAt = BigInt(object.opened_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.jury_case_id = message.juryCaseId !== BigInt(0) ? message.juryCaseId?.toString() : undefined;
+        obj.operator_address = message.operatorAddress === "" ? undefined : message.operatorAddress;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.opener = message.opener === "" ? undefined : message.opener;
+        obj.proposed_new_controller = message.proposedNewController === "" ? undefined : message.proposedNewController;
+        obj.deposit = message.deposit === "" ? undefined : message.deposit;
+        obj.opened_at = message.openedAt !== BigInt(0) ? message.openedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ControllerTransferCase.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/ControllerTransferCase",
+            value: ControllerTransferCase.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return ControllerTransferCase.decode(message.value);
+    },
+    toProto(message) {
+        return ControllerTransferCase.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.ControllerTransferCase",
+            value: ControllerTransferCase.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,240 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { ServiceTypeConfig } from "./service_type_config";
+import { Operator } from "./operator";
+import { Report } from "./report";
+import { Tier1EscrowEntry } from "./tier1_escrow_entry";
+import { ControllerTransferCase } from "./controller_transfer_case";
+import { ReporterRateLimit } from "./reporter_rate_limit";
+import { RefileCooldown } from "./refile_cooldown";
+import { Tier1LastSlash } from "./tier1_last_slash";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({}),
+        serviceTypes: [],
+        operators: [],
+        archivedOperators: [],
+        reports: [],
+        tier1Escrow: [],
+        controllerTransferCases: [],
+        reporterRateLimits: [],
+        refileCooldowns: [],
+        tier1LastSlash: [],
+        nextReportId: BigInt(0),
+        nextEscrowId: BigInt(0)
+    };
+}
+/**
+ * GenesisState defines the service module's genesis state. See
+ * x-service-spec.md §7 for full validation rules.
+ * @name GenesisState
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/sparkdream.service.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.serviceTypes) {
+            ServiceTypeConfig.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.operators) {
+            Operator.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.archivedOperators) {
+            Operator.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.reports) {
+            Report.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.tier1Escrow) {
+            Tier1EscrowEntry.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.controllerTransferCases) {
+            ControllerTransferCase.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        for (const v of message.reporterRateLimits) {
+            ReporterRateLimit.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        for (const v of message.refileCooldowns) {
+            RefileCooldown.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        for (const v of message.tier1LastSlash) {
+            Tier1LastSlash.encode(v, writer.uint32(82).fork()).ldelim();
+        }
+        if (message.nextReportId !== BigInt(0)) {
+            writer.uint32(88).uint64(message.nextReportId);
+        }
+        if (message.nextEscrowId !== BigInt(0)) {
+            writer.uint32(96).uint64(message.nextEscrowId);
+        }
+        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.serviceTypes.push(ServiceTypeConfig.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.operators.push(Operator.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.archivedOperators.push(Operator.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.reports.push(Report.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.tier1Escrow.push(Tier1EscrowEntry.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.controllerTransferCases.push(ControllerTransferCase.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.reporterRateLimits.push(ReporterRateLimit.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.refileCooldowns.push(RefileCooldown.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.tier1LastSlash.push(Tier1LastSlash.decode(reader, reader.uint32()));
+                    break;
+                case 11:
+                    message.nextReportId = reader.uint64();
+                    break;
+                case 12:
+                    message.nextEscrowId = reader.uint64();
+                    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.serviceTypes = object.serviceTypes?.map(e => ServiceTypeConfig.fromPartial(e)) || [];
+        message.operators = object.operators?.map(e => Operator.fromPartial(e)) || [];
+        message.archivedOperators = object.archivedOperators?.map(e => Operator.fromPartial(e)) || [];
+        message.reports = object.reports?.map(e => Report.fromPartial(e)) || [];
+        message.tier1Escrow = object.tier1Escrow?.map(e => Tier1EscrowEntry.fromPartial(e)) || [];
+        message.controllerTransferCases = object.controllerTransferCases?.map(e => ControllerTransferCase.fromPartial(e)) || [];
+        message.reporterRateLimits = object.reporterRateLimits?.map(e => ReporterRateLimit.fromPartial(e)) || [];
+        message.refileCooldowns = object.refileCooldowns?.map(e => RefileCooldown.fromPartial(e)) || [];
+        message.tier1LastSlash = object.tier1LastSlash?.map(e => Tier1LastSlash.fromPartial(e)) || [];
+        message.nextReportId = object.nextReportId !== undefined && object.nextReportId !== null ? BigInt(object.nextReportId.toString()) : BigInt(0);
+        message.nextEscrowId = object.nextEscrowId !== undefined && object.nextEscrowId !== null ? BigInt(object.nextEscrowId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        message.serviceTypes = object.service_types?.map(e => ServiceTypeConfig.fromAmino(e)) || [];
+        message.operators = object.operators?.map(e => Operator.fromAmino(e)) || [];
+        message.archivedOperators = object.archived_operators?.map(e => Operator.fromAmino(e)) || [];
+        message.reports = object.reports?.map(e => Report.fromAmino(e)) || [];
+        message.tier1Escrow = object.tier1_escrow?.map(e => Tier1EscrowEntry.fromAmino(e)) || [];
+        message.controllerTransferCases = object.controller_transfer_cases?.map(e => ControllerTransferCase.fromAmino(e)) || [];
+        message.reporterRateLimits = object.reporter_rate_limits?.map(e => ReporterRateLimit.fromAmino(e)) || [];
+        message.refileCooldowns = object.refile_cooldowns?.map(e => RefileCooldown.fromAmino(e)) || [];
+        message.tier1LastSlash = object.tier1_last_slash?.map(e => Tier1LastSlash.fromAmino(e)) || [];
+        if (object.next_report_id !== undefined && object.next_report_id !== null) {
+            message.nextReportId = BigInt(object.next_report_id);
+        }
+        if (object.next_escrow_id !== undefined && object.next_escrow_id !== null) {
+            message.nextEscrowId = BigInt(object.next_escrow_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        if (message.serviceTypes) {
+            obj.service_types = message.serviceTypes.map(e => e ? ServiceTypeConfig.toAmino(e) : undefined);
+        }
+        else {
+            obj.service_types = message.serviceTypes;
+        }
+        if (message.operators) {
+            obj.operators = message.operators.map(e => e ? Operator.toAmino(e) : undefined);
+        }
+        else {
+            obj.operators = message.operators;
+        }
+        if (message.archivedOperators) {
+            obj.archived_operators = message.archivedOperators.map(e => e ? Operator.toAmino(e) : undefined);
+        }
+        else {
+            obj.archived_operators = message.archivedOperators;
+        }
+        if (message.reports) {
+            obj.reports = message.reports.map(e => e ? Report.toAmino(e) : undefined);
+        }
+        else {
+            obj.reports = message.reports;
+        }
+        if (message.tier1Escrow) {
+            obj.tier1_escrow = message.tier1Escrow.map(e => e ? Tier1EscrowEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.tier1_escrow = message.tier1Escrow;
+        }
+        if (message.controllerTransferCases) {
+            obj.controller_transfer_cases = message.controllerTransferCases.map(e => e ? ControllerTransferCase.toAmino(e) : undefined);
+        }
+        else {
+            obj.controller_transfer_cases = message.controllerTransferCases;
+        }
+        if (message.reporterRateLimits) {
+            obj.reporter_rate_limits = message.reporterRateLimits.map(e => e ? ReporterRateLimit.toAmino(e) : undefined);
+        }
+        else {
+            obj.reporter_rate_limits = message.reporterRateLimits;
+        }
+        if (message.refileCooldowns) {
+            obj.refile_cooldowns = message.refileCooldowns.map(e => e ? RefileCooldown.toAmino(e) : undefined);
+        }
+        else {
+            obj.refile_cooldowns = message.refileCooldowns;
+        }
+        if (message.tier1LastSlash) {
+            obj.tier1_last_slash = message.tier1LastSlash.map(e => e ? Tier1LastSlash.toAmino(e) : undefined);
+        }
+        else {
+            obj.tier1_last_slash = message.tier1LastSlash;
+        }
+        obj.next_report_id = message.nextReportId !== BigInt(0) ? message.nextReportId?.toString() : undefined;
+        obj.next_escrow_id = message.nextEscrowId !== BigInt(0) ? message.nextEscrowId?.toString() : undefined;
+        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.service.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};