@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.32

package/akash/downtimedetector/v1beta1/downtime_duration.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Downtime defines the predefined downtime durations that can be tracked
+ * by the downtime detector module to monitor chain availability
+ */
+export declare enum Downtime {
+    /** DURATION_30S - DURATION_30S represents a 30 second downtime period */
+    DURATION_30S = 0,
+    /** DURATION_1M - DURATION_1M represents a 1 minute downtime period */
+    DURATION_1M = 1,
+    /** DURATION_2M - DURATION_2M represents a 2 minute downtime period */
+    DURATION_2M = 2,
+    /** DURATION_3M - DURATION_3M represents a 3 minute downtime period */
+    DURATION_3M = 3,
+    /** DURATION_4M - DURATION_4M represents a 4 minute downtime period */
+    DURATION_4M = 4,
+    /** DURATION_5M - DURATION_5M represents a 5 minute downtime period */
+    DURATION_5M = 5,
+    /** DURATION_10M - DURATION_10M represents a 10 minute downtime period */
+    DURATION_10M = 6,
+    /** DURATION_20M - DURATION_20M represents a 20 minute downtime period */
+    DURATION_20M = 7,
+    /** DURATION_30M - DURATION_30M represents a 30 minute downtime period */
+    DURATION_30M = 8,
+    /** DURATION_40M - DURATION_40M represents a 40 minute downtime period */
+    DURATION_40M = 9,
+    /** DURATION_50M - DURATION_50M represents a 50 minute downtime period */
+    DURATION_50M = 10,
+    /** DURATION_1H - DURATION_1H represents a 1 hour downtime period */
+    DURATION_1H = 11,
+    /** DURATION_1_5H - DURATION_1_5H represents a 1.5 hour downtime period */
+    DURATION_1_5H = 12,
+    /** DURATION_2H - DURATION_2H represents a 2 hour downtime period */
+    DURATION_2H = 13,
+    /** DURATION_2_5H - DURATION_2_5H represents a 2.5 hour downtime period */
+    DURATION_2_5H = 14,
+    /** DURATION_3H - DURATION_3H represents a 3 hour downtime period */
+    DURATION_3H = 15,
+    /** DURATION_4H - DURATION_4H represents a 4 hour downtime period */
+    DURATION_4H = 16,
+    /** DURATION_5H - DURATION_5H represents a 5 hour downtime period */
+    DURATION_5H = 17,
+    /** DURATION_6H - DURATION_6H represents a 6 hour downtime period */
+    DURATION_6H = 18,
+    /** DURATION_9H - DURATION_9H represents a 9 hour downtime period */
+    DURATION_9H = 19,
+    /** DURATION_12H - DURATION_12H represents a 12 hour downtime period */
+    DURATION_12H = 20,
+    /** DURATION_18H - DURATION_18H represents a 18 hour downtime period */
+    DURATION_18H = 21,
+    /** DURATION_24H - DURATION_24H represents a 24 hour downtime period */
+    DURATION_24H = 22,
+    /** DURATION_36H - DURATION_36H represents a 36 hour downtime period */
+    DURATION_36H = 23,
+    /** DURATION_48H - DURATION_48H represents a 48 hour downtime period */
+    DURATION_48H = 24,
+    UNRECOGNIZED = -1
+}
+export declare const DowntimeAmino: typeof Downtime;
+export declare function downtimeFromJSON(object: any): Downtime;
+export declare function downtimeToJSON(object: Downtime): string;

package/akash/downtimedetector/v1beta1/downtime_duration.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DowntimeAmino = exports.Downtime = void 0;
+exports.downtimeFromJSON = downtimeFromJSON;
+exports.downtimeToJSON = downtimeToJSON;
+//@ts-nocheck
+/**
+ * Downtime defines the predefined downtime durations that can be tracked
+ * by the downtime detector module to monitor chain availability
+ */
+var Downtime;
+(function (Downtime) {
+    /** DURATION_30S - DURATION_30S represents a 30 second downtime period */
+    Downtime[Downtime["DURATION_30S"] = 0] = "DURATION_30S";
+    /** DURATION_1M - DURATION_1M represents a 1 minute downtime period */
+    Downtime[Downtime["DURATION_1M"] = 1] = "DURATION_1M";
+    /** DURATION_2M - DURATION_2M represents a 2 minute downtime period */
+    Downtime[Downtime["DURATION_2M"] = 2] = "DURATION_2M";
+    /** DURATION_3M - DURATION_3M represents a 3 minute downtime period */
+    Downtime[Downtime["DURATION_3M"] = 3] = "DURATION_3M";
+    /** DURATION_4M - DURATION_4M represents a 4 minute downtime period */
+    Downtime[Downtime["DURATION_4M"] = 4] = "DURATION_4M";
+    /** DURATION_5M - DURATION_5M represents a 5 minute downtime period */
+    Downtime[Downtime["DURATION_5M"] = 5] = "DURATION_5M";
+    /** DURATION_10M - DURATION_10M represents a 10 minute downtime period */
+    Downtime[Downtime["DURATION_10M"] = 6] = "DURATION_10M";
+    /** DURATION_20M - DURATION_20M represents a 20 minute downtime period */
+    Downtime[Downtime["DURATION_20M"] = 7] = "DURATION_20M";
+    /** DURATION_30M - DURATION_30M represents a 30 minute downtime period */
+    Downtime[Downtime["DURATION_30M"] = 8] = "DURATION_30M";
+    /** DURATION_40M - DURATION_40M represents a 40 minute downtime period */
+    Downtime[Downtime["DURATION_40M"] = 9] = "DURATION_40M";
+    /** DURATION_50M - DURATION_50M represents a 50 minute downtime period */
+    Downtime[Downtime["DURATION_50M"] = 10] = "DURATION_50M";
+    /** DURATION_1H - DURATION_1H represents a 1 hour downtime period */
+    Downtime[Downtime["DURATION_1H"] = 11] = "DURATION_1H";
+    /** DURATION_1_5H - DURATION_1_5H represents a 1.5 hour downtime period */
+    Downtime[Downtime["DURATION_1_5H"] = 12] = "DURATION_1_5H";
+    /** DURATION_2H - DURATION_2H represents a 2 hour downtime period */
+    Downtime[Downtime["DURATION_2H"] = 13] = "DURATION_2H";
+    /** DURATION_2_5H - DURATION_2_5H represents a 2.5 hour downtime period */
+    Downtime[Downtime["DURATION_2_5H"] = 14] = "DURATION_2_5H";
+    /** DURATION_3H - DURATION_3H represents a 3 hour downtime period */
+    Downtime[Downtime["DURATION_3H"] = 15] = "DURATION_3H";
+    /** DURATION_4H - DURATION_4H represents a 4 hour downtime period */
+    Downtime[Downtime["DURATION_4H"] = 16] = "DURATION_4H";
+    /** DURATION_5H - DURATION_5H represents a 5 hour downtime period */
+    Downtime[Downtime["DURATION_5H"] = 17] = "DURATION_5H";
+    /** DURATION_6H - DURATION_6H represents a 6 hour downtime period */
+    Downtime[Downtime["DURATION_6H"] = 18] = "DURATION_6H";
+    /** DURATION_9H - DURATION_9H represents a 9 hour downtime period */
+    Downtime[Downtime["DURATION_9H"] = 19] = "DURATION_9H";
+    /** DURATION_12H - DURATION_12H represents a 12 hour downtime period */
+    Downtime[Downtime["DURATION_12H"] = 20] = "DURATION_12H";
+    /** DURATION_18H - DURATION_18H represents a 18 hour downtime period */
+    Downtime[Downtime["DURATION_18H"] = 21] = "DURATION_18H";
+    /** DURATION_24H - DURATION_24H represents a 24 hour downtime period */
+    Downtime[Downtime["DURATION_24H"] = 22] = "DURATION_24H";
+    /** DURATION_36H - DURATION_36H represents a 36 hour downtime period */
+    Downtime[Downtime["DURATION_36H"] = 23] = "DURATION_36H";
+    /** DURATION_48H - DURATION_48H represents a 48 hour downtime period */
+    Downtime[Downtime["DURATION_48H"] = 24] = "DURATION_48H";
+    Downtime[Downtime["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Downtime || (exports.Downtime = Downtime = {}));
+exports.DowntimeAmino = Downtime;
+function downtimeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "DURATION_30S":
+            return Downtime.DURATION_30S;
+        case 1:
+        case "DURATION_1M":
+            return Downtime.DURATION_1M;
+        case 2:
+        case "DURATION_2M":
+            return Downtime.DURATION_2M;
+        case 3:
+        case "DURATION_3M":
+            return Downtime.DURATION_3M;
+        case 4:
+        case "DURATION_4M":
+            return Downtime.DURATION_4M;
+        case 5:
+        case "DURATION_5M":
+            return Downtime.DURATION_5M;
+        case 6:
+        case "DURATION_10M":
+            return Downtime.DURATION_10M;
+        case 7:
+        case "DURATION_20M":
+            return Downtime.DURATION_20M;
+        case 8:
+        case "DURATION_30M":
+            return Downtime.DURATION_30M;
+        case 9:
+        case "DURATION_40M":
+            return Downtime.DURATION_40M;
+        case 10:
+        case "DURATION_50M":
+            return Downtime.DURATION_50M;
+        case 11:
+        case "DURATION_1H":
+            return Downtime.DURATION_1H;
+        case 12:
+        case "DURATION_1_5H":
+            return Downtime.DURATION_1_5H;
+        case 13:
+        case "DURATION_2H":
+            return Downtime.DURATION_2H;
+        case 14:
+        case "DURATION_2_5H":
+            return Downtime.DURATION_2_5H;
+        case 15:
+        case "DURATION_3H":
+            return Downtime.DURATION_3H;
+        case 16:
+        case "DURATION_4H":
+            return Downtime.DURATION_4H;
+        case 17:
+        case "DURATION_5H":
+            return Downtime.DURATION_5H;
+        case 18:
+        case "DURATION_6H":
+            return Downtime.DURATION_6H;
+        case 19:
+        case "DURATION_9H":
+            return Downtime.DURATION_9H;
+        case 20:
+        case "DURATION_12H":
+            return Downtime.DURATION_12H;
+        case 21:
+        case "DURATION_18H":
+            return Downtime.DURATION_18H;
+        case 22:
+        case "DURATION_24H":
+            return Downtime.DURATION_24H;
+        case 23:
+        case "DURATION_36H":
+            return Downtime.DURATION_36H;
+        case 24:
+        case "DURATION_48H":
+            return Downtime.DURATION_48H;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Downtime.UNRECOGNIZED;
+    }
+}
+function downtimeToJSON(object) {
+    switch (object) {
+        case Downtime.DURATION_30S:
+            return "DURATION_30S";
+        case Downtime.DURATION_1M:
+            return "DURATION_1M";
+        case Downtime.DURATION_2M:
+            return "DURATION_2M";
+        case Downtime.DURATION_3M:
+            return "DURATION_3M";
+        case Downtime.DURATION_4M:
+            return "DURATION_4M";
+        case Downtime.DURATION_5M:
+            return "DURATION_5M";
+        case Downtime.DURATION_10M:
+            return "DURATION_10M";
+        case Downtime.DURATION_20M:
+            return "DURATION_20M";
+        case Downtime.DURATION_30M:
+            return "DURATION_30M";
+        case Downtime.DURATION_40M:
+            return "DURATION_40M";
+        case Downtime.DURATION_50M:
+            return "DURATION_50M";
+        case Downtime.DURATION_1H:
+            return "DURATION_1H";
+        case Downtime.DURATION_1_5H:
+            return "DURATION_1_5H";
+        case Downtime.DURATION_2H:
+            return "DURATION_2H";
+        case Downtime.DURATION_2_5H:
+            return "DURATION_2_5H";
+        case Downtime.DURATION_3H:
+            return "DURATION_3H";
+        case Downtime.DURATION_4H:
+            return "DURATION_4H";
+        case Downtime.DURATION_5H:
+            return "DURATION_5H";
+        case Downtime.DURATION_6H:
+            return "DURATION_6H";
+        case Downtime.DURATION_9H:
+            return "DURATION_9H";
+        case Downtime.DURATION_12H:
+            return "DURATION_12H";
+        case Downtime.DURATION_18H:
+            return "DURATION_18H";
+        case Downtime.DURATION_24H:
+            return "DURATION_24H";
+        case Downtime.DURATION_36H:
+            return "DURATION_36H";
+        case Downtime.DURATION_48H:
+            return "DURATION_48H";
+        case Downtime.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/akash/downtimedetector/v1beta1/genesis.d.ts

@@ -0,0 +1,119 @@
+import { Downtime } from "./downtime_duration";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GenesisDowntimeEntry tracks the last occurrence of a specific downtime duration
+ * @name GenesisDowntimeEntry
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisDowntimeEntry
+ */
+export interface GenesisDowntimeEntry {
+    /**
+     * duration is the downtime period being tracked
+     */
+    duration: Downtime;
+    /**
+     * last_downtime is the timestamp when this downtime duration was last observed
+     */
+    lastDowntime: Date;
+}
+export interface GenesisDowntimeEntryProtoMsg {
+    typeUrl: "/akash.downtimedetector.v1beta1.GenesisDowntimeEntry";
+    value: Uint8Array;
+}
+/**
+ * GenesisDowntimeEntry tracks the last occurrence of a specific downtime duration
+ * @name GenesisDowntimeEntryAmino
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisDowntimeEntry
+ */
+export interface GenesisDowntimeEntryAmino {
+    /**
+     * duration is the downtime period being tracked
+     */
+    duration?: Downtime;
+    /**
+     * last_downtime is the timestamp when this downtime duration was last observed
+     */
+    last_downtime?: string;
+}
+export interface GenesisDowntimeEntryAminoMsg {
+    type: "/akash.downtimedetector.v1beta1.GenesisDowntimeEntry";
+    value: GenesisDowntimeEntryAmino;
+}
+/**
+ * GenesisState defines the downtime detector module's genesis state
+ * @name GenesisState
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisState
+ */
+export interface GenesisState {
+    /**
+     * downtimes is the list of tracked downtime entries
+     */
+    downtimes: GenesisDowntimeEntry[];
+    /**
+     * last_block_time is the timestamp of the last processed block
+     */
+    lastBlockTime: Date;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/akash.downtimedetector.v1beta1.GenesisState";
+    value: Uint8Array;
+}
+/**
+ * GenesisState defines the downtime detector module's genesis state
+ * @name GenesisStateAmino
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisState
+ */
+export interface GenesisStateAmino {
+    /**
+     * downtimes is the list of tracked downtime entries
+     */
+    downtimes?: GenesisDowntimeEntryAmino[];
+    /**
+     * last_block_time is the timestamp of the last processed block
+     */
+    last_block_time?: string;
+}
+export interface GenesisStateAminoMsg {
+    type: "/akash.downtimedetector.v1beta1.GenesisState";
+    value: GenesisStateAmino;
+}
+/**
+ * GenesisDowntimeEntry tracks the last occurrence of a specific downtime duration
+ * @name GenesisDowntimeEntry
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisDowntimeEntry
+ */
+export declare const GenesisDowntimeEntry: {
+    typeUrl: string;
+    encode(message: GenesisDowntimeEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisDowntimeEntry;
+    fromPartial(object: DeepPartial<GenesisDowntimeEntry>): GenesisDowntimeEntry;
+    fromAmino(object: GenesisDowntimeEntryAmino): GenesisDowntimeEntry;
+    toAmino(message: GenesisDowntimeEntry): GenesisDowntimeEntryAmino;
+    fromAminoMsg(object: GenesisDowntimeEntryAminoMsg): GenesisDowntimeEntry;
+    fromProtoMsg(message: GenesisDowntimeEntryProtoMsg): GenesisDowntimeEntry;
+    toProto(message: GenesisDowntimeEntry): Uint8Array;
+    toProtoMsg(message: GenesisDowntimeEntry): GenesisDowntimeEntryProtoMsg;
+};
+/**
+ * GenesisState defines the downtime detector module's genesis state
+ * @name GenesisState
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisState
+ */
+export declare const GenesisState: {
+    typeUrl: string;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/akash/downtimedetector/v1beta1/genesis.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = exports.GenesisDowntimeEntry = void 0;
+const timestamp_1 = require("../../../google/protobuf/timestamp");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseGenesisDowntimeEntry() {
+    return {
+        duration: 0,
+        lastDowntime: new Date()
+    };
+}
+/**
+ * GenesisDowntimeEntry tracks the last occurrence of a specific downtime duration
+ * @name GenesisDowntimeEntry
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisDowntimeEntry
+ */
+exports.GenesisDowntimeEntry = {
+    typeUrl: "/akash.downtimedetector.v1beta1.GenesisDowntimeEntry",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.duration !== 0) {
+            writer.uint32(8).int32(message.duration);
+        }
+        if (message.lastDowntime !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.toTimestamp)(message.lastDowntime), writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisDowntimeEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.duration = reader.int32();
+                    break;
+                case 2:
+                    message.lastDowntime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisDowntimeEntry();
+        message.duration = object.duration ?? 0;
+        message.lastDowntime = object.lastDowntime ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisDowntimeEntry();
+        if (object.duration !== undefined && object.duration !== null) {
+            message.duration = object.duration;
+        }
+        if (object.last_downtime !== undefined && object.last_downtime !== null) {
+            message.lastDowntime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.fromAmino(object.last_downtime));
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.duration = message.duration === 0 ? undefined : message.duration;
+        obj.last_downtime = message.lastDowntime ? timestamp_1.Timestamp.toAmino((0, helpers_1.toTimestamp)(message.lastDowntime)) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisDowntimeEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisDowntimeEntry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisDowntimeEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.downtimedetector.v1beta1.GenesisDowntimeEntry",
+            value: exports.GenesisDowntimeEntry.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisState() {
+    return {
+        downtimes: [],
+        lastBlockTime: new Date()
+    };
+}
+/**
+ * GenesisState defines the downtime detector module's genesis state
+ * @name GenesisState
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.GenesisState
+ */
+exports.GenesisState = {
+    typeUrl: "/akash.downtimedetector.v1beta1.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.downtimes) {
+            exports.GenesisDowntimeEntry.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.lastBlockTime !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.toTimestamp)(message.lastBlockTime), writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.downtimes.push(exports.GenesisDowntimeEntry.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.lastBlockTime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.downtimes = object.downtimes?.map(e => exports.GenesisDowntimeEntry.fromPartial(e)) || [];
+        message.lastBlockTime = object.lastBlockTime ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.downtimes = object.downtimes?.map(e => exports.GenesisDowntimeEntry.fromAmino(e)) || [];
+        if (object.last_block_time !== undefined && object.last_block_time !== null) {
+            message.lastBlockTime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.fromAmino(object.last_block_time));
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.downtimes) {
+            obj.downtimes = message.downtimes.map(e => e ? exports.GenesisDowntimeEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.downtimes = message.downtimes;
+        }
+        obj.last_block_time = message.lastBlockTime ? timestamp_1.Timestamp.toAmino((0, helpers_1.toTimestamp)(message.lastBlockTime)) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.downtimedetector.v1beta1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/akash/downtimedetector/v1beta1/query.d.ts

@@ -0,0 +1,120 @@
+import { Downtime } from "./downtime_duration";
+import { Duration, DurationAmino } from "../../../google/protobuf/duration";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * RecoveredSinceDowntimeOfLengthRequest is the request type for querying if the chain
+ * has been operational for at least the specified recovery duration since experiencing
+ * downtime of the specified length
+ * @name RecoveredSinceDowntimeOfLengthRequest
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest
+ */
+export interface RecoveredSinceDowntimeOfLengthRequest {
+    /**
+     * downtime is the downtime duration to check against
+     */
+    downtime: Downtime;
+    /**
+     * recovery is the minimum recovery duration required since the downtime
+     */
+    recovery: Duration;
+}
+export interface RecoveredSinceDowntimeOfLengthRequestProtoMsg {
+    typeUrl: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest";
+    value: Uint8Array;
+}
+/**
+ * RecoveredSinceDowntimeOfLengthRequest is the request type for querying if the chain
+ * has been operational for at least the specified recovery duration since experiencing
+ * downtime of the specified length
+ * @name RecoveredSinceDowntimeOfLengthRequestAmino
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest
+ */
+export interface RecoveredSinceDowntimeOfLengthRequestAmino {
+    /**
+     * downtime is the downtime duration to check against
+     */
+    downtime?: Downtime;
+    /**
+     * recovery is the minimum recovery duration required since the downtime
+     */
+    recovery?: DurationAmino;
+}
+export interface RecoveredSinceDowntimeOfLengthRequestAminoMsg {
+    type: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest";
+    value: RecoveredSinceDowntimeOfLengthRequestAmino;
+}
+/**
+ * RecoveredSinceDowntimeOfLengthResponse is the response type for the recovery query
+ * @name RecoveredSinceDowntimeOfLengthResponse
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse
+ */
+export interface RecoveredSinceDowntimeOfLengthResponse {
+    /**
+     * succesfully_recovered indicates if the chain has been up for at least the recovery
+     * duration since the last downtime of the specified length
+     */
+    succesfullyRecovered: boolean;
+}
+export interface RecoveredSinceDowntimeOfLengthResponseProtoMsg {
+    typeUrl: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse";
+    value: Uint8Array;
+}
+/**
+ * RecoveredSinceDowntimeOfLengthResponse is the response type for the recovery query
+ * @name RecoveredSinceDowntimeOfLengthResponseAmino
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse
+ */
+export interface RecoveredSinceDowntimeOfLengthResponseAmino {
+    /**
+     * succesfully_recovered indicates if the chain has been up for at least the recovery
+     * duration since the last downtime of the specified length
+     */
+    succesfully_recovered?: boolean;
+}
+export interface RecoveredSinceDowntimeOfLengthResponseAminoMsg {
+    type: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse";
+    value: RecoveredSinceDowntimeOfLengthResponseAmino;
+}
+/**
+ * RecoveredSinceDowntimeOfLengthRequest is the request type for querying if the chain
+ * has been operational for at least the specified recovery duration since experiencing
+ * downtime of the specified length
+ * @name RecoveredSinceDowntimeOfLengthRequest
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest
+ */
+export declare const RecoveredSinceDowntimeOfLengthRequest: {
+    typeUrl: string;
+    encode(message: RecoveredSinceDowntimeOfLengthRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RecoveredSinceDowntimeOfLengthRequest;
+    fromPartial(object: DeepPartial<RecoveredSinceDowntimeOfLengthRequest>): RecoveredSinceDowntimeOfLengthRequest;
+    fromAmino(object: RecoveredSinceDowntimeOfLengthRequestAmino): RecoveredSinceDowntimeOfLengthRequest;
+    toAmino(message: RecoveredSinceDowntimeOfLengthRequest): RecoveredSinceDowntimeOfLengthRequestAmino;
+    fromAminoMsg(object: RecoveredSinceDowntimeOfLengthRequestAminoMsg): RecoveredSinceDowntimeOfLengthRequest;
+    fromProtoMsg(message: RecoveredSinceDowntimeOfLengthRequestProtoMsg): RecoveredSinceDowntimeOfLengthRequest;
+    toProto(message: RecoveredSinceDowntimeOfLengthRequest): Uint8Array;
+    toProtoMsg(message: RecoveredSinceDowntimeOfLengthRequest): RecoveredSinceDowntimeOfLengthRequestProtoMsg;
+};
+/**
+ * RecoveredSinceDowntimeOfLengthResponse is the response type for the recovery query
+ * @name RecoveredSinceDowntimeOfLengthResponse
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse
+ */
+export declare const RecoveredSinceDowntimeOfLengthResponse: {
+    typeUrl: string;
+    encode(message: RecoveredSinceDowntimeOfLengthResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RecoveredSinceDowntimeOfLengthResponse;
+    fromPartial(object: DeepPartial<RecoveredSinceDowntimeOfLengthResponse>): RecoveredSinceDowntimeOfLengthResponse;
+    fromAmino(object: RecoveredSinceDowntimeOfLengthResponseAmino): RecoveredSinceDowntimeOfLengthResponse;
+    toAmino(message: RecoveredSinceDowntimeOfLengthResponse): RecoveredSinceDowntimeOfLengthResponseAmino;
+    fromAminoMsg(object: RecoveredSinceDowntimeOfLengthResponseAminoMsg): RecoveredSinceDowntimeOfLengthResponse;
+    fromProtoMsg(message: RecoveredSinceDowntimeOfLengthResponseProtoMsg): RecoveredSinceDowntimeOfLengthResponse;
+    toProto(message: RecoveredSinceDowntimeOfLengthResponse): Uint8Array;
+    toProtoMsg(message: RecoveredSinceDowntimeOfLengthResponse): RecoveredSinceDowntimeOfLengthResponseProtoMsg;
+};