@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

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

@@ -0,0 +1,353 @@
+//@ts-nocheck
+/**
+ * OperatorStatus is the lifecycle status of a service-operator record.
+ * ACTIVE | UNDERFUNDED | UNBONDING are live; SLASHED | RETIRED are terminal
+ * and held in ArchivedOperators (see x-service-spec.md §3.1).
+ */
+export var OperatorStatus;
+(function (OperatorStatus) {
+    OperatorStatus[OperatorStatus["OPERATOR_STATUS_UNSPECIFIED"] = 0] = "OPERATOR_STATUS_UNSPECIFIED";
+    OperatorStatus[OperatorStatus["OPERATOR_STATUS_ACTIVE"] = 1] = "OPERATOR_STATUS_ACTIVE";
+    OperatorStatus[OperatorStatus["OPERATOR_STATUS_UNDERFUNDED"] = 2] = "OPERATOR_STATUS_UNDERFUNDED";
+    OperatorStatus[OperatorStatus["OPERATOR_STATUS_UNBONDING"] = 3] = "OPERATOR_STATUS_UNBONDING";
+    OperatorStatus[OperatorStatus["OPERATOR_STATUS_SLASHED"] = 4] = "OPERATOR_STATUS_SLASHED";
+    OperatorStatus[OperatorStatus["OPERATOR_STATUS_RETIRED"] = 5] = "OPERATOR_STATUS_RETIRED";
+    OperatorStatus[OperatorStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OperatorStatus || (OperatorStatus = {}));
+export const OperatorStatusAmino = OperatorStatus;
+export function operatorStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "OPERATOR_STATUS_UNSPECIFIED":
+            return OperatorStatus.OPERATOR_STATUS_UNSPECIFIED;
+        case 1:
+        case "OPERATOR_STATUS_ACTIVE":
+            return OperatorStatus.OPERATOR_STATUS_ACTIVE;
+        case 2:
+        case "OPERATOR_STATUS_UNDERFUNDED":
+            return OperatorStatus.OPERATOR_STATUS_UNDERFUNDED;
+        case 3:
+        case "OPERATOR_STATUS_UNBONDING":
+            return OperatorStatus.OPERATOR_STATUS_UNBONDING;
+        case 4:
+        case "OPERATOR_STATUS_SLASHED":
+            return OperatorStatus.OPERATOR_STATUS_SLASHED;
+        case 5:
+        case "OPERATOR_STATUS_RETIRED":
+            return OperatorStatus.OPERATOR_STATUS_RETIRED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OperatorStatus.UNRECOGNIZED;
+    }
+}
+export function operatorStatusToJSON(object) {
+    switch (object) {
+        case OperatorStatus.OPERATOR_STATUS_UNSPECIFIED:
+            return "OPERATOR_STATUS_UNSPECIFIED";
+        case OperatorStatus.OPERATOR_STATUS_ACTIVE:
+            return "OPERATOR_STATUS_ACTIVE";
+        case OperatorStatus.OPERATOR_STATUS_UNDERFUNDED:
+            return "OPERATOR_STATUS_UNDERFUNDED";
+        case OperatorStatus.OPERATOR_STATUS_UNBONDING:
+            return "OPERATOR_STATUS_UNBONDING";
+        case OperatorStatus.OPERATOR_STATUS_SLASHED:
+            return "OPERATOR_STATUS_SLASHED";
+        case OperatorStatus.OPERATOR_STATUS_RETIRED:
+            return "OPERATOR_STATUS_RETIRED";
+        case OperatorStatus.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** ReportStatus is the lifecycle status of a Report (see §3.4.5). */
+export var ReportStatus;
+(function (ReportStatus) {
+    ReportStatus[ReportStatus["REPORT_STATUS_UNSPECIFIED"] = 0] = "REPORT_STATUS_UNSPECIFIED";
+    ReportStatus[ReportStatus["REPORT_STATUS_PENDING"] = 1] = "REPORT_STATUS_PENDING";
+    ReportStatus[ReportStatus["REPORT_STATUS_RESOLVED_T1"] = 2] = "REPORT_STATUS_RESOLVED_T1";
+    ReportStatus[ReportStatus["REPORT_STATUS_ESCALATED"] = 3] = "REPORT_STATUS_ESCALATED";
+    ReportStatus[ReportStatus["REPORT_STATUS_RESOLVED_T2"] = 4] = "REPORT_STATUS_RESOLVED_T2";
+    ReportStatus[ReportStatus["REPORT_STATUS_AUTO_DISMISSED"] = 5] = "REPORT_STATUS_AUTO_DISMISSED";
+    ReportStatus[ReportStatus["REPORT_STATUS_AUTO_TIMEOUT"] = 6] = "REPORT_STATUS_AUTO_TIMEOUT";
+    ReportStatus[ReportStatus["REPORT_STATUS_CLOSED_OPERATOR_DISSOLVED"] = 7] = "REPORT_STATUS_CLOSED_OPERATOR_DISSOLVED";
+    ReportStatus[ReportStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ReportStatus || (ReportStatus = {}));
+export const ReportStatusAmino = ReportStatus;
+export function reportStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "REPORT_STATUS_UNSPECIFIED":
+            return ReportStatus.REPORT_STATUS_UNSPECIFIED;
+        case 1:
+        case "REPORT_STATUS_PENDING":
+            return ReportStatus.REPORT_STATUS_PENDING;
+        case 2:
+        case "REPORT_STATUS_RESOLVED_T1":
+            return ReportStatus.REPORT_STATUS_RESOLVED_T1;
+        case 3:
+        case "REPORT_STATUS_ESCALATED":
+            return ReportStatus.REPORT_STATUS_ESCALATED;
+        case 4:
+        case "REPORT_STATUS_RESOLVED_T2":
+            return ReportStatus.REPORT_STATUS_RESOLVED_T2;
+        case 5:
+        case "REPORT_STATUS_AUTO_DISMISSED":
+            return ReportStatus.REPORT_STATUS_AUTO_DISMISSED;
+        case 6:
+        case "REPORT_STATUS_AUTO_TIMEOUT":
+            return ReportStatus.REPORT_STATUS_AUTO_TIMEOUT;
+        case 7:
+        case "REPORT_STATUS_CLOSED_OPERATOR_DISSOLVED":
+            return ReportStatus.REPORT_STATUS_CLOSED_OPERATOR_DISSOLVED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ReportStatus.UNRECOGNIZED;
+    }
+}
+export function reportStatusToJSON(object) {
+    switch (object) {
+        case ReportStatus.REPORT_STATUS_UNSPECIFIED:
+            return "REPORT_STATUS_UNSPECIFIED";
+        case ReportStatus.REPORT_STATUS_PENDING:
+            return "REPORT_STATUS_PENDING";
+        case ReportStatus.REPORT_STATUS_RESOLVED_T1:
+            return "REPORT_STATUS_RESOLVED_T1";
+        case ReportStatus.REPORT_STATUS_ESCALATED:
+            return "REPORT_STATUS_ESCALATED";
+        case ReportStatus.REPORT_STATUS_RESOLVED_T2:
+            return "REPORT_STATUS_RESOLVED_T2";
+        case ReportStatus.REPORT_STATUS_AUTO_DISMISSED:
+            return "REPORT_STATUS_AUTO_DISMISSED";
+        case ReportStatus.REPORT_STATUS_AUTO_TIMEOUT:
+            return "REPORT_STATUS_AUTO_TIMEOUT";
+        case ReportStatus.REPORT_STATUS_CLOSED_OPERATOR_DISSOLVED:
+            return "REPORT_STATUS_CLOSED_OPERATOR_DISSOLVED";
+        case ReportStatus.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** ResolveVerdict is the controller's verdict on a PENDING report (§5.2). */
+export var ResolveVerdict;
+(function (ResolveVerdict) {
+    ResolveVerdict[ResolveVerdict["RESOLVE_VERDICT_UNSPECIFIED"] = 0] = "RESOLVE_VERDICT_UNSPECIFIED";
+    ResolveVerdict[ResolveVerdict["RESOLVE_VERDICT_T1_SLASH"] = 1] = "RESOLVE_VERDICT_T1_SLASH";
+    ResolveVerdict[ResolveVerdict["RESOLVE_VERDICT_T1_DISMISS"] = 2] = "RESOLVE_VERDICT_T1_DISMISS";
+    ResolveVerdict[ResolveVerdict["RESOLVE_VERDICT_ESCALATE_TO_JURY"] = 3] = "RESOLVE_VERDICT_ESCALATE_TO_JURY";
+    ResolveVerdict[ResolveVerdict["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ResolveVerdict || (ResolveVerdict = {}));
+export const ResolveVerdictAmino = ResolveVerdict;
+export function resolveVerdictFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "RESOLVE_VERDICT_UNSPECIFIED":
+            return ResolveVerdict.RESOLVE_VERDICT_UNSPECIFIED;
+        case 1:
+        case "RESOLVE_VERDICT_T1_SLASH":
+            return ResolveVerdict.RESOLVE_VERDICT_T1_SLASH;
+        case 2:
+        case "RESOLVE_VERDICT_T1_DISMISS":
+            return ResolveVerdict.RESOLVE_VERDICT_T1_DISMISS;
+        case 3:
+        case "RESOLVE_VERDICT_ESCALATE_TO_JURY":
+            return ResolveVerdict.RESOLVE_VERDICT_ESCALATE_TO_JURY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ResolveVerdict.UNRECOGNIZED;
+    }
+}
+export function resolveVerdictToJSON(object) {
+    switch (object) {
+        case ResolveVerdict.RESOLVE_VERDICT_UNSPECIFIED:
+            return "RESOLVE_VERDICT_UNSPECIFIED";
+        case ResolveVerdict.RESOLVE_VERDICT_T1_SLASH:
+            return "RESOLVE_VERDICT_T1_SLASH";
+        case ResolveVerdict.RESOLVE_VERDICT_T1_DISMISS:
+            return "RESOLVE_VERDICT_T1_DISMISS";
+        case ResolveVerdict.RESOLVE_VERDICT_ESCALATE_TO_JURY:
+            return "RESOLVE_VERDICT_ESCALATE_TO_JURY";
+        case ResolveVerdict.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** JuryVerdict is the jury's verdict on a service.slash case (§5.2). */
+export var JuryVerdict;
+(function (JuryVerdict) {
+    JuryVerdict[JuryVerdict["JURY_VERDICT_UNSPECIFIED"] = 0] = "JURY_VERDICT_UNSPECIFIED";
+    JuryVerdict[JuryVerdict["JURY_VERDICT_ACCEPT"] = 1] = "JURY_VERDICT_ACCEPT";
+    JuryVerdict[JuryVerdict["JURY_VERDICT_REDUCE"] = 2] = "JURY_VERDICT_REDUCE";
+    JuryVerdict[JuryVerdict["JURY_VERDICT_REJECT"] = 3] = "JURY_VERDICT_REJECT";
+    JuryVerdict[JuryVerdict["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(JuryVerdict || (JuryVerdict = {}));
+export const JuryVerdictAmino = JuryVerdict;
+export function juryVerdictFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "JURY_VERDICT_UNSPECIFIED":
+            return JuryVerdict.JURY_VERDICT_UNSPECIFIED;
+        case 1:
+        case "JURY_VERDICT_ACCEPT":
+            return JuryVerdict.JURY_VERDICT_ACCEPT;
+        case 2:
+        case "JURY_VERDICT_REDUCE":
+            return JuryVerdict.JURY_VERDICT_REDUCE;
+        case 3:
+        case "JURY_VERDICT_REJECT":
+            return JuryVerdict.JURY_VERDICT_REJECT;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return JuryVerdict.UNRECOGNIZED;
+    }
+}
+export function juryVerdictToJSON(object) {
+    switch (object) {
+        case JuryVerdict.JURY_VERDICT_UNSPECIFIED:
+            return "JURY_VERDICT_UNSPECIFIED";
+        case JuryVerdict.JURY_VERDICT_ACCEPT:
+            return "JURY_VERDICT_ACCEPT";
+        case JuryVerdict.JURY_VERDICT_REDUCE:
+            return "JURY_VERDICT_REDUCE";
+        case JuryVerdict.JURY_VERDICT_REJECT:
+            return "JURY_VERDICT_REJECT";
+        case JuryVerdict.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/**
+ * TransferVerdict is the jury's verdict on a service.controller_transfer
+ * case (§5.4). Binary — no REDUCE.
+ */
+export var TransferVerdict;
+(function (TransferVerdict) {
+    TransferVerdict[TransferVerdict["TRANSFER_VERDICT_UNSPECIFIED"] = 0] = "TRANSFER_VERDICT_UNSPECIFIED";
+    TransferVerdict[TransferVerdict["TRANSFER_VERDICT_ACCEPT"] = 1] = "TRANSFER_VERDICT_ACCEPT";
+    TransferVerdict[TransferVerdict["TRANSFER_VERDICT_REJECT"] = 2] = "TRANSFER_VERDICT_REJECT";
+    TransferVerdict[TransferVerdict["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(TransferVerdict || (TransferVerdict = {}));
+export const TransferVerdictAmino = TransferVerdict;
+export function transferVerdictFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "TRANSFER_VERDICT_UNSPECIFIED":
+            return TransferVerdict.TRANSFER_VERDICT_UNSPECIFIED;
+        case 1:
+        case "TRANSFER_VERDICT_ACCEPT":
+            return TransferVerdict.TRANSFER_VERDICT_ACCEPT;
+        case 2:
+        case "TRANSFER_VERDICT_REJECT":
+            return TransferVerdict.TRANSFER_VERDICT_REJECT;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return TransferVerdict.UNRECOGNIZED;
+    }
+}
+export function transferVerdictToJSON(object) {
+    switch (object) {
+        case TransferVerdict.TRANSFER_VERDICT_UNSPECIFIED:
+            return "TRANSFER_VERDICT_UNSPECIFIED";
+        case TransferVerdict.TRANSFER_VERDICT_ACCEPT:
+            return "TRANSFER_VERDICT_ACCEPT";
+        case TransferVerdict.TRANSFER_VERDICT_REJECT:
+            return "TRANSFER_VERDICT_REJECT";
+        case TransferVerdict.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/**
+ * SlashSource identifies the origin of a slash for keeper-level invariant
+ * dispatch (§6.7). Internal to the keeper; not serialized in events.
+ */
+export var SlashSource;
+(function (SlashSource) {
+    SlashSource[SlashSource["SLASH_SOURCE_UNSPECIFIED"] = 0] = "SLASH_SOURCE_UNSPECIFIED";
+    SlashSource[SlashSource["SLASH_SOURCE_TIER1"] = 1] = "SLASH_SOURCE_TIER1";
+    SlashSource[SlashSource["SLASH_SOURCE_TIER2_JURY"] = 2] = "SLASH_SOURCE_TIER2_JURY";
+    SlashSource[SlashSource["SLASH_SOURCE_MIGRATION"] = 3] = "SLASH_SOURCE_MIGRATION";
+    SlashSource[SlashSource["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(SlashSource || (SlashSource = {}));
+export const SlashSourceAmino = SlashSource;
+export function slashSourceFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SLASH_SOURCE_UNSPECIFIED":
+            return SlashSource.SLASH_SOURCE_UNSPECIFIED;
+        case 1:
+        case "SLASH_SOURCE_TIER1":
+            return SlashSource.SLASH_SOURCE_TIER1;
+        case 2:
+        case "SLASH_SOURCE_TIER2_JURY":
+            return SlashSource.SLASH_SOURCE_TIER2_JURY;
+        case 3:
+        case "SLASH_SOURCE_MIGRATION":
+            return SlashSource.SLASH_SOURCE_MIGRATION;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return SlashSource.UNRECOGNIZED;
+    }
+}
+export function slashSourceToJSON(object) {
+    switch (object) {
+        case SlashSource.SLASH_SOURCE_UNSPECIFIED:
+            return "SLASH_SOURCE_UNSPECIFIED";
+        case SlashSource.SLASH_SOURCE_TIER1:
+            return "SLASH_SOURCE_TIER1";
+        case SlashSource.SLASH_SOURCE_TIER2_JURY:
+            return "SLASH_SOURCE_TIER2_JURY";
+        case SlashSource.SLASH_SOURCE_MIGRATION:
+            return "SLASH_SOURCE_MIGRATION";
+        case SlashSource.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/**
+ * UnbondSource distinguishes voluntary vs forced unbonding for telemetry
+ * and event emission (§12 events).
+ */
+export var UnbondSource;
+(function (UnbondSource) {
+    UnbondSource[UnbondSource["UNBOND_SOURCE_UNSPECIFIED"] = 0] = "UNBOND_SOURCE_UNSPECIFIED";
+    UnbondSource[UnbondSource["UNBOND_SOURCE_VOLUNTARY"] = 1] = "UNBOND_SOURCE_VOLUNTARY";
+    UnbondSource[UnbondSource["UNBOND_SOURCE_FORCED_UNDERFUNDED"] = 2] = "UNBOND_SOURCE_FORCED_UNDERFUNDED";
+    UnbondSource[UnbondSource["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(UnbondSource || (UnbondSource = {}));
+export const UnbondSourceAmino = UnbondSource;
+export function unbondSourceFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "UNBOND_SOURCE_UNSPECIFIED":
+            return UnbondSource.UNBOND_SOURCE_UNSPECIFIED;
+        case 1:
+        case "UNBOND_SOURCE_VOLUNTARY":
+            return UnbondSource.UNBOND_SOURCE_VOLUNTARY;
+        case 2:
+        case "UNBOND_SOURCE_FORCED_UNDERFUNDED":
+            return UnbondSource.UNBOND_SOURCE_FORCED_UNDERFUNDED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return UnbondSource.UNRECOGNIZED;
+    }
+}
+export function unbondSourceToJSON(object) {
+    switch (object) {
+        case UnbondSource.UNBOND_SOURCE_UNSPECIFIED:
+            return "UNBOND_SOURCE_UNSPECIFIED";
+        case UnbondSource.UNBOND_SOURCE_VOLUNTARY:
+            return "UNBOND_SOURCE_VOLUNTARY";
+        case UnbondSource.UNBOND_SOURCE_FORCED_UNDERFUNDED:
+            return "UNBOND_SOURCE_FORCED_UNDERFUNDED";
+        case UnbondSource.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

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

@@ -1,15 +1,22 @@
 //@ts-nocheck
 import { Params } from "./params";
-import { Session } from "./session";
+import { Grant } from "./grant";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 function createBaseGenesisState() {
     return {
         params: Params.fromPartial({}),
-        sessions: []
+        grants: [],
+        grantSeq: BigInt(0),
+        activeGrantCounts: []
     };
 }
 /**
  * GenesisState defines the session module's genesis state.
+ *
+ * Active grants (typically empty at genesis). The secondary indexes
+ * (GrantsByGranter, GrantsByGrantee, GrantsByExpiration, etc.) are
+ * reconstructed from the grants list on InitGenesis and not exported, so
+ * the round-trip stays small and cannot double-count.
  * @name GenesisState
  * @package sparkdream.session.v1
  * @see proto type: sparkdream.session.v1.GenesisState
@@ -20,8 +27,14 @@ export const GenesisState = {
         if (message.params !== undefined) {
             Params.encode(message.params, writer.uint32(10).fork()).ldelim();
         }
-        for (const v of message.sessions) {
-            Session.encode(v, writer.uint32(18).fork()).ldelim();
+        for (const v of message.grants) {
+            Grant.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.grantSeq !== BigInt(0)) {
+            writer.uint32(24).uint64(message.grantSeq);
+        }
+        for (const v of message.activeGrantCounts) {
+            ActiveGrantCount.encode(v, writer.uint32(34).fork()).ldelim();
         }
         return writer;
     },
@@ -36,7 +49,13 @@ export const GenesisState = {
                     message.params = Params.decode(reader, reader.uint32());
                     break;
                 case 2:
-                    message.sessions.push(Session.decode(reader, reader.uint32()));
+                    message.grants.push(Grant.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.grantSeq = reader.uint64();
+                    break;
+                case 4:
+                    message.activeGrantCounts.push(ActiveGrantCount.decode(reader, reader.uint32()));
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -48,7 +67,9 @@ export const GenesisState = {
     fromPartial(object) {
         const message = createBaseGenesisState();
         message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
-        message.sessions = object.sessions?.map(e => Session.fromPartial(e)) || [];
+        message.grants = object.grants?.map(e => Grant.fromPartial(e)) || [];
+        message.grantSeq = object.grantSeq !== undefined && object.grantSeq !== null ? BigInt(object.grantSeq.toString()) : BigInt(0);
+        message.activeGrantCounts = object.activeGrantCounts?.map(e => ActiveGrantCount.fromPartial(e)) || [];
         return message;
     },
     fromAmino(object) {
@@ -56,17 +77,28 @@ export const GenesisState = {
         if (object.params !== undefined && object.params !== null) {
             message.params = Params.fromAmino(object.params);
         }
-        message.sessions = object.sessions?.map(e => Session.fromAmino(e)) || [];
+        message.grants = object.grants?.map(e => Grant.fromAmino(e)) || [];
+        if (object.grant_seq !== undefined && object.grant_seq !== null) {
+            message.grantSeq = BigInt(object.grant_seq);
+        }
+        message.activeGrantCounts = object.active_grant_counts?.map(e => ActiveGrantCount.fromAmino(e)) || [];
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
-        if (message.sessions) {
-            obj.sessions = message.sessions.map(e => e ? Session.toAmino(e) : undefined);
+        if (message.grants) {
+            obj.grants = message.grants.map(e => e ? Grant.toAmino(e) : undefined);
+        }
+        else {
+            obj.grants = message.grants;
+        }
+        obj.grant_seq = message.grantSeq !== BigInt(0) ? message.grantSeq?.toString() : undefined;
+        if (message.activeGrantCounts) {
+            obj.active_grant_counts = message.activeGrantCounts.map(e => e ? ActiveGrantCount.toAmino(e) : undefined);
         }
         else {
-            obj.sessions = message.sessions;
+            obj.active_grant_counts = message.activeGrantCounts;
         }
         return obj;
     },
@@ -86,3 +118,97 @@ export const GenesisState = {
         };
     }
 };
+function createBaseActiveGrantCount() {
+    return {
+        granter: "",
+        type: 0,
+        count: 0
+    };
+}
+/**
+ * ActiveGrantCount carries one (granter, type) -> active count entry for
+ * the genesis export round-trip.
+ * @name ActiveGrantCount
+ * @package sparkdream.session.v1
+ * @see proto type: sparkdream.session.v1.ActiveGrantCount
+ */
+export const ActiveGrantCount = {
+    typeUrl: "/sparkdream.session.v1.ActiveGrantCount",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.granter !== "") {
+            writer.uint32(10).string(message.granter);
+        }
+        if (message.type !== 0) {
+            writer.uint32(16).int32(message.type);
+        }
+        if (message.count !== 0) {
+            writer.uint32(24).uint32(message.count);
+        }
+        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 = createBaseActiveGrantCount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.granter = reader.string();
+                    break;
+                case 2:
+                    message.type = reader.int32();
+                    break;
+                case 3:
+                    message.count = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseActiveGrantCount();
+        message.granter = object.granter ?? "";
+        message.type = object.type ?? 0;
+        message.count = object.count ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseActiveGrantCount();
+        if (object.granter !== undefined && object.granter !== null) {
+            message.granter = object.granter;
+        }
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        if (object.count !== undefined && object.count !== null) {
+            message.count = object.count;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.granter = message.granter === "" ? undefined : message.granter;
+        obj.type = message.type === 0 ? undefined : message.type;
+        obj.count = message.count === 0 ? undefined : message.count;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ActiveGrantCount.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ActiveGrantCount.decode(message.value);
+    },
+    toProto(message) {
+        return ActiveGrantCount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.session.v1.ActiveGrantCount",
+            value: ActiveGrantCount.encode(message).finish()
+        };
+    }
+};