@sparkdreamnft/sparkdreamjs 0.0.16 → 0.0.18

package/sparkdream/service/v1/query.lcd.d.ts

@@ -0,0 +1,18 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryOperatorRequest, QueryOperatorResponse, QueryServiceTypeRequest, QueryServiceTypeResponse, QueryServiceTypesRequest, QueryServiceTypesResponse, QueryOperatorsRequest, QueryOperatorsResponse, QueryOperatorsByControllerRequest, QueryOperatorsByControllerResponse, QueryOperatorsByServiceTypeRequest, QueryOperatorsByServiceTypeResponse, QueryReportRequest, QueryReportResponse, QueryReportsByOperatorRequest, QueryReportsByOperatorResponse, QueryOperatorReputationSnapshotRequest, QueryOperatorReputationSnapshotResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    operator: (params: QueryOperatorRequest) => Promise<QueryOperatorResponse>;
+    serviceType: (params: QueryServiceTypeRequest) => Promise<QueryServiceTypeResponse>;
+    serviceTypes: (params: QueryServiceTypesRequest) => Promise<QueryServiceTypesResponse>;
+    operators: (params: QueryOperatorsRequest) => Promise<QueryOperatorsResponse>;
+    operatorsByController: (params: QueryOperatorsByControllerRequest) => Promise<QueryOperatorsByControllerResponse>;
+    operatorsByServiceType: (params: QueryOperatorsByServiceTypeRequest) => Promise<QueryOperatorsByServiceTypeResponse>;
+    report: (params: QueryReportRequest) => Promise<QueryReportResponse>;
+    reportsByOperator: (params: QueryReportsByOperatorRequest) => Promise<QueryReportsByOperatorResponse>;
+    operatorReputationSnapshot: (params: QueryOperatorReputationSnapshotRequest) => Promise<QueryOperatorReputationSnapshotResponse>;
+}

package/sparkdream/service/v1/query.lcd.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+//@ts-nocheck
+const helpers_1 = require("../../../helpers");
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/service/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* Operator returns the live operator record for (address, service_type). */
+    operator = async (params) => {
+        const endpoint = `sparkdream/service/v1/operator/${params.address}/${params.serviceType}`;
+        return await this.req.get(endpoint);
+    };
+    /* ServiceType returns one service-type registry entry. */
+    serviceType = async (params) => {
+        const endpoint = `sparkdream/service/v1/service_type/${params.serviceType}`;
+        return await this.req.get(endpoint);
+    };
+    /* ServiceTypes returns all service-type registry entries (paginated). */
+    serviceTypes = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.enabledOnly !== "undefined") {
+            options.params.enabled_only = params.enabledOnly;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/service_types`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Operators returns all live operator records (paginated, optionally
+     filtered by status). */
+    operators = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/operators`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OperatorsByController returns live operators whose controller is the
+     given address. */
+    operatorsByController = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/operators_by_controller/${params.controller}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OperatorsByServiceType returns live operators of the given service type. */
+    operatorsByServiceType = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/operators_by_service_type/${params.serviceType}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Report returns a single report by id. */
+    report = async (params) => {
+        const endpoint = `sparkdream/service/v1/report/${params.reportId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ReportsByOperator returns reports against (operator_address, service_type). */
+    reportsByOperator = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/reports_by_operator/${params.operatorAddress}/${params.serviceType}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OperatorReputationSnapshot returns bond-block totals for an address
+     (§6.6 lazy accrual visibility). Settles in-memory at query time; no
+     state write. */
+    operatorReputationSnapshot = async (params) => {
+        const endpoint = `sparkdream/service/v1/operator_reputation_snapshot/${params.address}`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/sparkdream/service/v1/query.rpc.Query.d.ts

@@ -0,0 +1,63 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryOperatorRequest, QueryOperatorResponse, QueryServiceTypeRequest, QueryServiceTypeResponse, QueryServiceTypesRequest, QueryServiceTypesResponse, QueryOperatorsRequest, QueryOperatorsResponse, QueryOperatorsByControllerRequest, QueryOperatorsByControllerResponse, QueryOperatorsByServiceTypeRequest, QueryOperatorsByServiceTypeResponse, QueryReportRequest, QueryReportResponse, QueryReportsByOperatorRequest, QueryReportsByOperatorResponse, QueryOperatorReputationSnapshotRequest, QueryOperatorReputationSnapshotResponse } from "./query";
+/** Query defines the gRPC querier service for x/service.
+ See x-service-spec.md §8. */
+export interface Query {
+    /** Parameters queries the parameters of the module. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** Operator returns the live operator record for (address, service_type). */
+    operator(request: QueryOperatorRequest): Promise<QueryOperatorResponse>;
+    /** ServiceType returns one service-type registry entry. */
+    serviceType(request: QueryServiceTypeRequest): Promise<QueryServiceTypeResponse>;
+    /** ServiceTypes returns all service-type registry entries (paginated). */
+    serviceTypes(request: QueryServiceTypesRequest): Promise<QueryServiceTypesResponse>;
+    /**
+     * Operators returns all live operator records (paginated, optionally
+     * filtered by status).
+     */
+    operators(request: QueryOperatorsRequest): Promise<QueryOperatorsResponse>;
+    /**
+     * OperatorsByController returns live operators whose controller is the
+     * given address.
+     */
+    operatorsByController(request: QueryOperatorsByControllerRequest): Promise<QueryOperatorsByControllerResponse>;
+    /** OperatorsByServiceType returns live operators of the given service type. */
+    operatorsByServiceType(request: QueryOperatorsByServiceTypeRequest): Promise<QueryOperatorsByServiceTypeResponse>;
+    /** Report returns a single report by id. */
+    report(request: QueryReportRequest): Promise<QueryReportResponse>;
+    /** ReportsByOperator returns reports against (operator_address, service_type). */
+    reportsByOperator(request: QueryReportsByOperatorRequest): Promise<QueryReportsByOperatorResponse>;
+    /**
+     * OperatorReputationSnapshot returns bond-block totals for an address
+     * (§6.6 lazy accrual visibility). Settles in-memory at query time; no
+     * state write.
+     */
+    operatorReputationSnapshot(request: QueryOperatorReputationSnapshotRequest): Promise<QueryOperatorReputationSnapshotResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    operator: (request: QueryOperatorRequest) => Promise<QueryOperatorResponse>;
+    serviceType: (request: QueryServiceTypeRequest) => Promise<QueryServiceTypeResponse>;
+    serviceTypes: (request: QueryServiceTypesRequest) => Promise<QueryServiceTypesResponse>;
+    operators: (request: QueryOperatorsRequest) => Promise<QueryOperatorsResponse>;
+    operatorsByController: (request: QueryOperatorsByControllerRequest) => Promise<QueryOperatorsByControllerResponse>;
+    operatorsByServiceType: (request: QueryOperatorsByServiceTypeRequest) => Promise<QueryOperatorsByServiceTypeResponse>;
+    report: (request: QueryReportRequest) => Promise<QueryReportResponse>;
+    reportsByOperator: (request: QueryReportsByOperatorRequest) => Promise<QueryReportsByOperatorResponse>;
+    operatorReputationSnapshot: (request: QueryOperatorReputationSnapshotRequest) => Promise<QueryOperatorReputationSnapshotResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    operator(request: QueryOperatorRequest): Promise<QueryOperatorResponse>;
+    serviceType(request: QueryServiceTypeRequest): Promise<QueryServiceTypeResponse>;
+    serviceTypes(request: QueryServiceTypesRequest): Promise<QueryServiceTypesResponse>;
+    operators(request: QueryOperatorsRequest): Promise<QueryOperatorsResponse>;
+    operatorsByController(request: QueryOperatorsByControllerRequest): Promise<QueryOperatorsByControllerResponse>;
+    operatorsByServiceType(request: QueryOperatorsByServiceTypeRequest): Promise<QueryOperatorsByServiceTypeResponse>;
+    report(request: QueryReportRequest): Promise<QueryReportResponse>;
+    reportsByOperator(request: QueryReportsByOperatorRequest): Promise<QueryReportsByOperatorResponse>;
+    operatorReputationSnapshot(request: QueryOperatorReputationSnapshotRequest): Promise<QueryOperatorReputationSnapshotResponse>;
+};

package/sparkdream/service/v1/query.rpc.Query.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Operator returns the live operator record for (address, service_type). */
+    operator = async (request) => {
+        const data = query_1.QueryOperatorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Operator", data);
+        return promise.then(data => query_1.QueryOperatorResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ServiceType returns one service-type registry entry. */
+    serviceType = async (request) => {
+        const data = query_1.QueryServiceTypeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "ServiceType", data);
+        return promise.then(data => query_1.QueryServiceTypeResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ServiceTypes returns all service-type registry entries (paginated). */
+    serviceTypes = async (request) => {
+        const data = query_1.QueryServiceTypesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "ServiceTypes", data);
+        return promise.then(data => query_1.QueryServiceTypesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Operators returns all live operator records (paginated, optionally
+     filtered by status). */
+    operators = async (request) => {
+        const data = query_1.QueryOperatorsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Operators", data);
+        return promise.then(data => query_1.QueryOperatorsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* OperatorsByController returns live operators whose controller is the
+     given address. */
+    operatorsByController = async (request) => {
+        const data = query_1.QueryOperatorsByControllerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "OperatorsByController", data);
+        return promise.then(data => query_1.QueryOperatorsByControllerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* OperatorsByServiceType returns live operators of the given service type. */
+    operatorsByServiceType = async (request) => {
+        const data = query_1.QueryOperatorsByServiceTypeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "OperatorsByServiceType", data);
+        return promise.then(data => query_1.QueryOperatorsByServiceTypeResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Report returns a single report by id. */
+    report = async (request) => {
+        const data = query_1.QueryReportRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Report", data);
+        return promise.then(data => query_1.QueryReportResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ReportsByOperator returns reports against (operator_address, service_type). */
+    reportsByOperator = async (request) => {
+        const data = query_1.QueryReportsByOperatorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "ReportsByOperator", data);
+        return promise.then(data => query_1.QueryReportsByOperatorResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* OperatorReputationSnapshot returns bond-block totals for an address
+     (§6.6 lazy accrual visibility). Settles in-memory at query time; no
+     state write. */
+    operatorReputationSnapshot = async (request) => {
+        const data = query_1.QueryOperatorReputationSnapshotRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "OperatorReputationSnapshot", data);
+        return promise.then(data => query_1.QueryOperatorReputationSnapshotResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        operator(request) {
+            return queryService.operator(request);
+        },
+        serviceType(request) {
+            return queryService.serviceType(request);
+        },
+        serviceTypes(request) {
+            return queryService.serviceTypes(request);
+        },
+        operators(request) {
+            return queryService.operators(request);
+        },
+        operatorsByController(request) {
+            return queryService.operatorsByController(request);
+        },
+        operatorsByServiceType(request) {
+            return queryService.operatorsByServiceType(request);
+        },
+        report(request) {
+            return queryService.report(request);
+        },
+        reportsByOperator(request) {
+            return queryService.reportsByOperator(request);
+        },
+        operatorReputationSnapshot(request) {
+            return queryService.operatorReputationSnapshot(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/sparkdream/service/v1/refile_cooldown.d.ts

@@ -0,0 +1,105 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * RefileCooldown bars a controller from re-filing the same allegation
+ * against the same (operator, service_type) within
+ * `report_refile_cooldown_blocks` after a PENDING report was
+ * AUTO_DISMISSED (controller stall). See x-service-spec.md §3.4.5.
+ *
+ * Keyed by (controller, operator_address, service_type, dismissed_at)
+ * in the RefileCooldowns store; lazy expiry — entries are checked at
+ * MsgReportOperator time and pruned when expired.
+ * @name RefileCooldown
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.RefileCooldown
+ */
+export interface RefileCooldown {
+    /**
+     * controller is the bech32 address of the controller against whom the
+     * cooldown applies.
+     */
+    controller: string;
+    /**
+     * operator_address is the operator the prior dismissed report targeted.
+     */
+    operatorAddress: string;
+    /**
+     * service_type identifies the operator record.
+     */
+    serviceType: string;
+    /**
+     * dismissed_at is the height the prior PENDING report was
+     * AUTO_DISMISSED. Cooldown expires at
+     * `dismissed_at + report_refile_cooldown_blocks`.
+     */
+    dismissedAt: bigint;
+}
+export interface RefileCooldownProtoMsg {
+    typeUrl: "/sparkdream.service.v1.RefileCooldown";
+    value: Uint8Array;
+}
+/**
+ * RefileCooldown bars a controller from re-filing the same allegation
+ * against the same (operator, service_type) within
+ * `report_refile_cooldown_blocks` after a PENDING report was
+ * AUTO_DISMISSED (controller stall). See x-service-spec.md §3.4.5.
+ *
+ * Keyed by (controller, operator_address, service_type, dismissed_at)
+ * in the RefileCooldowns store; lazy expiry — entries are checked at
+ * MsgReportOperator time and pruned when expired.
+ * @name RefileCooldownAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.RefileCooldown
+ */
+export interface RefileCooldownAmino {
+    /**
+     * controller is the bech32 address of the controller against whom the
+     * cooldown applies.
+     */
+    controller?: string;
+    /**
+     * operator_address is the operator the prior dismissed report targeted.
+     */
+    operator_address?: string;
+    /**
+     * service_type identifies the operator record.
+     */
+    service_type?: string;
+    /**
+     * dismissed_at is the height the prior PENDING report was
+     * AUTO_DISMISSED. Cooldown expires at
+     * `dismissed_at + report_refile_cooldown_blocks`.
+     */
+    dismissed_at?: string;
+}
+export interface RefileCooldownAminoMsg {
+    type: "sparkdream/x/service/RefileCooldown";
+    value: RefileCooldownAmino;
+}
+/**
+ * RefileCooldown bars a controller from re-filing the same allegation
+ * against the same (operator, service_type) within
+ * `report_refile_cooldown_blocks` after a PENDING report was
+ * AUTO_DISMISSED (controller stall). See x-service-spec.md §3.4.5.
+ *
+ * Keyed by (controller, operator_address, service_type, dismissed_at)
+ * in the RefileCooldowns store; lazy expiry — entries are checked at
+ * MsgReportOperator time and pruned when expired.
+ * @name RefileCooldown
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.RefileCooldown
+ */
+export declare const RefileCooldown: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: RefileCooldown, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RefileCooldown;
+    fromPartial(object: DeepPartial<RefileCooldown>): RefileCooldown;
+    fromAmino(object: RefileCooldownAmino): RefileCooldown;
+    toAmino(message: RefileCooldown): RefileCooldownAmino;
+    fromAminoMsg(object: RefileCooldownAminoMsg): RefileCooldown;
+    toAminoMsg(message: RefileCooldown): RefileCooldownAminoMsg;
+    fromProtoMsg(message: RefileCooldownProtoMsg): RefileCooldown;
+    toProto(message: RefileCooldown): Uint8Array;
+    toProtoMsg(message: RefileCooldown): RefileCooldownProtoMsg;
+};

package/sparkdream/service/v1/refile_cooldown.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefileCooldown = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseRefileCooldown() {
+    return {
+        controller: "",
+        operatorAddress: "",
+        serviceType: "",
+        dismissedAt: BigInt(0)
+    };
+}
+/**
+ * RefileCooldown bars a controller from re-filing the same allegation
+ * against the same (operator, service_type) within
+ * `report_refile_cooldown_blocks` after a PENDING report was
+ * AUTO_DISMISSED (controller stall). See x-service-spec.md §3.4.5.
+ *
+ * Keyed by (controller, operator_address, service_type, dismissed_at)
+ * in the RefileCooldowns store; lazy expiry — entries are checked at
+ * MsgReportOperator time and pruned when expired.
+ * @name RefileCooldown
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.RefileCooldown
+ */
+exports.RefileCooldown = {
+    typeUrl: "/sparkdream.service.v1.RefileCooldown",
+    aminoType: "sparkdream/x/service/RefileCooldown",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.controller !== "") {
+            writer.uint32(10).string(message.controller);
+        }
+        if (message.operatorAddress !== "") {
+            writer.uint32(18).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        if (message.dismissedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.dismissedAt);
+        }
+        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 = createBaseRefileCooldown();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.controller = reader.string();
+                    break;
+                case 2:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    message.dismissedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRefileCooldown();
+        message.controller = object.controller ?? "";
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.dismissedAt = object.dismissedAt !== undefined && object.dismissedAt !== null ? BigInt(object.dismissedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRefileCooldown();
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        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.dismissed_at !== undefined && object.dismissed_at !== null) {
+            message.dismissedAt = BigInt(object.dismissed_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.operator_address = message.operatorAddress === "" ? undefined : message.operatorAddress;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.dismissed_at = message.dismissedAt !== BigInt(0) ? message.dismissedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.RefileCooldown.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/RefileCooldown",
+            value: exports.RefileCooldown.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.RefileCooldown.decode(message.value);
+    },
+    toProto(message) {
+        return exports.RefileCooldown.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.RefileCooldown",
+            value: exports.RefileCooldown.encode(message).finish()
+        };
+    }
+};