@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

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()
+        };
+    }
+};

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

@@ -0,0 +1,250 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBaseOperator() {
+    return {
+        address: "",
+        serviceType: "",
+        controller: "",
+        bondAmount: "",
+        metadata: new Uint8Array(),
+        status: 0,
+        underfundedSince: BigInt(0),
+        unbondCompleteAt: BigInt(0),
+        tier1SlashedInWindow: "",
+        tier1WindowStart: BigInt(0),
+        tier1WindowStartBond: "",
+        registeredAt: BigInt(0),
+        retiredAt: BigInt(0),
+        totalLifetimeBondBlocks: "",
+        lastBondBlockUpdateAt: BigInt(0)
+    };
+}
+/**
+ * Operator is the canonical record for a SPARK-bonded external-service
+ * operator (see x-service-spec.md §3.1). Live records (status ∈
+ * {ACTIVE, UNDERFUNDED, UNBONDING}) live in the Operators store keyed by
+ * (address, service_type); terminal records (SLASHED, RETIRED) are moved
+ * to ArchivedOperators at the terminal transition.
+ * @name Operator
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Operator
+ */
+export const Operator = {
+    typeUrl: "/sparkdream.service.v1.Operator",
+    aminoType: "sparkdream/x/service/Operator",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.controller !== "") {
+            writer.uint32(26).string(message.controller);
+        }
+        if (message.bondAmount !== "") {
+            writer.uint32(34).string(message.bondAmount);
+        }
+        if (message.metadata.length !== 0) {
+            writer.uint32(42).bytes(message.metadata);
+        }
+        if (message.status !== 0) {
+            writer.uint32(48).int32(message.status);
+        }
+        if (message.underfundedSince !== BigInt(0)) {
+            writer.uint32(56).int64(message.underfundedSince);
+        }
+        if (message.unbondCompleteAt !== BigInt(0)) {
+            writer.uint32(64).int64(message.unbondCompleteAt);
+        }
+        if (message.tier1SlashedInWindow !== "") {
+            writer.uint32(74).string(message.tier1SlashedInWindow);
+        }
+        if (message.tier1WindowStart !== BigInt(0)) {
+            writer.uint32(80).int64(message.tier1WindowStart);
+        }
+        if (message.tier1WindowStartBond !== "") {
+            writer.uint32(90).string(message.tier1WindowStartBond);
+        }
+        if (message.registeredAt !== BigInt(0)) {
+            writer.uint32(96).int64(message.registeredAt);
+        }
+        if (message.retiredAt !== BigInt(0)) {
+            writer.uint32(104).int64(message.retiredAt);
+        }
+        if (message.totalLifetimeBondBlocks !== "") {
+            writer.uint32(114).string(message.totalLifetimeBondBlocks);
+        }
+        if (message.lastBondBlockUpdateAt !== BigInt(0)) {
+            writer.uint32(120).int64(message.lastBondBlockUpdateAt);
+        }
+        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 = createBaseOperator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.controller = reader.string();
+                    break;
+                case 4:
+                    message.bondAmount = reader.string();
+                    break;
+                case 5:
+                    message.metadata = reader.bytes();
+                    break;
+                case 6:
+                    message.status = reader.int32();
+                    break;
+                case 7:
+                    message.underfundedSince = reader.int64();
+                    break;
+                case 8:
+                    message.unbondCompleteAt = reader.int64();
+                    break;
+                case 9:
+                    message.tier1SlashedInWindow = reader.string();
+                    break;
+                case 10:
+                    message.tier1WindowStart = reader.int64();
+                    break;
+                case 11:
+                    message.tier1WindowStartBond = reader.string();
+                    break;
+                case 12:
+                    message.registeredAt = reader.int64();
+                    break;
+                case 13:
+                    message.retiredAt = reader.int64();
+                    break;
+                case 14:
+                    message.totalLifetimeBondBlocks = reader.string();
+                    break;
+                case 15:
+                    message.lastBondBlockUpdateAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseOperator();
+        message.address = object.address ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.controller = object.controller ?? "";
+        message.bondAmount = object.bondAmount ?? "";
+        message.metadata = object.metadata ?? new Uint8Array();
+        message.status = object.status ?? 0;
+        message.underfundedSince = object.underfundedSince !== undefined && object.underfundedSince !== null ? BigInt(object.underfundedSince.toString()) : BigInt(0);
+        message.unbondCompleteAt = object.unbondCompleteAt !== undefined && object.unbondCompleteAt !== null ? BigInt(object.unbondCompleteAt.toString()) : BigInt(0);
+        message.tier1SlashedInWindow = object.tier1SlashedInWindow ?? "";
+        message.tier1WindowStart = object.tier1WindowStart !== undefined && object.tier1WindowStart !== null ? BigInt(object.tier1WindowStart.toString()) : BigInt(0);
+        message.tier1WindowStartBond = object.tier1WindowStartBond ?? "";
+        message.registeredAt = object.registeredAt !== undefined && object.registeredAt !== null ? BigInt(object.registeredAt.toString()) : BigInt(0);
+        message.retiredAt = object.retiredAt !== undefined && object.retiredAt !== null ? BigInt(object.retiredAt.toString()) : BigInt(0);
+        message.totalLifetimeBondBlocks = object.totalLifetimeBondBlocks ?? "";
+        message.lastBondBlockUpdateAt = object.lastBondBlockUpdateAt !== undefined && object.lastBondBlockUpdateAt !== null ? BigInt(object.lastBondBlockUpdateAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseOperator();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        if (object.bond_amount !== undefined && object.bond_amount !== null) {
+            message.bondAmount = object.bond_amount;
+        }
+        if (object.metadata !== undefined && object.metadata !== null) {
+            message.metadata = bytesFromBase64(object.metadata);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.underfunded_since !== undefined && object.underfunded_since !== null) {
+            message.underfundedSince = BigInt(object.underfunded_since);
+        }
+        if (object.unbond_complete_at !== undefined && object.unbond_complete_at !== null) {
+            message.unbondCompleteAt = BigInt(object.unbond_complete_at);
+        }
+        if (object.tier1_slashed_in_window !== undefined && object.tier1_slashed_in_window !== null) {
+            message.tier1SlashedInWindow = object.tier1_slashed_in_window;
+        }
+        if (object.tier1_window_start !== undefined && object.tier1_window_start !== null) {
+            message.tier1WindowStart = BigInt(object.tier1_window_start);
+        }
+        if (object.tier1_window_start_bond !== undefined && object.tier1_window_start_bond !== null) {
+            message.tier1WindowStartBond = object.tier1_window_start_bond;
+        }
+        if (object.registered_at !== undefined && object.registered_at !== null) {
+            message.registeredAt = BigInt(object.registered_at);
+        }
+        if (object.retired_at !== undefined && object.retired_at !== null) {
+            message.retiredAt = BigInt(object.retired_at);
+        }
+        if (object.total_lifetime_bond_blocks !== undefined && object.total_lifetime_bond_blocks !== null) {
+            message.totalLifetimeBondBlocks = object.total_lifetime_bond_blocks;
+        }
+        if (object.last_bond_block_update_at !== undefined && object.last_bond_block_update_at !== null) {
+            message.lastBondBlockUpdateAt = BigInt(object.last_bond_block_update_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.bond_amount = message.bondAmount === "" ? undefined : message.bondAmount;
+        obj.metadata = message.metadata ? base64FromBytes(message.metadata) : undefined;
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.underfunded_since = message.underfundedSince !== BigInt(0) ? message.underfundedSince?.toString() : undefined;
+        obj.unbond_complete_at = message.unbondCompleteAt !== BigInt(0) ? message.unbondCompleteAt?.toString() : undefined;
+        obj.tier1_slashed_in_window = message.tier1SlashedInWindow === "" ? undefined : message.tier1SlashedInWindow;
+        obj.tier1_window_start = message.tier1WindowStart !== BigInt(0) ? message.tier1WindowStart?.toString() : undefined;
+        obj.tier1_window_start_bond = message.tier1WindowStartBond === "" ? undefined : message.tier1WindowStartBond;
+        obj.registered_at = message.registeredAt !== BigInt(0) ? message.registeredAt?.toString() : undefined;
+        obj.retired_at = message.retiredAt !== BigInt(0) ? message.retiredAt?.toString() : undefined;
+        obj.total_lifetime_bond_blocks = message.totalLifetimeBondBlocks === "" ? undefined : message.totalLifetimeBondBlocks;
+        obj.last_bond_block_update_at = message.lastBondBlockUpdateAt !== BigInt(0) ? message.lastBondBlockUpdateAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Operator.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Operator",
+            value: Operator.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Operator.decode(message.value);
+    },
+    toProto(message) {
+        return Operator.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Operator",
+            value: Operator.encode(message).finish()
+        };
+    }
+};