@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.32

package/esm/akash/downtimedetector/v1beta1/downtime_duration.js

@@ -0,0 +1,200 @@
+//@ts-nocheck
+/**
+ * Downtime defines the predefined downtime durations that can be tracked
+ * by the downtime detector module to monitor chain availability
+ */
+export 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 || (Downtime = {}));
+export const DowntimeAmino = Downtime;
+export 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;
+    }
+}
+export 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/esm/akash/downtimedetector/v1beta1/genesis.js

@@ -0,0 +1,168 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../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
+ */
+export const GenesisDowntimeEntry = {
+    typeUrl: "/akash.downtimedetector.v1beta1.GenesisDowntimeEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.duration !== 0) {
+            writer.uint32(8).int32(message.duration);
+        }
+        if (message.lastDowntime !== undefined) {
+            Timestamp.encode(toTimestamp(message.lastDowntime), writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseGenesisDowntimeEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.duration = reader.int32();
+                    break;
+                case 2:
+                    message.lastDowntime = fromTimestamp(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 = fromTimestamp(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.toAmino(toTimestamp(message.lastDowntime)) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisDowntimeEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisDowntimeEntry.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisDowntimeEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.downtimedetector.v1beta1.GenesisDowntimeEntry",
+            value: 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
+ */
+export const GenesisState = {
+    typeUrl: "/akash.downtimedetector.v1beta1.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.downtimes) {
+            GenesisDowntimeEntry.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.lastBlockTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.lastBlockTime), writer.uint32(18).fork()).ldelim();
+        }
+        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.downtimes.push(GenesisDowntimeEntry.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.lastBlockTime = fromTimestamp(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 => GenesisDowntimeEntry.fromPartial(e)) || [];
+        message.lastBlockTime = object.lastBlockTime ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.downtimes = object.downtimes?.map(e => GenesisDowntimeEntry.fromAmino(e)) || [];
+        if (object.last_block_time !== undefined && object.last_block_time !== null) {
+            message.lastBlockTime = fromTimestamp(Timestamp.fromAmino(object.last_block_time));
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.downtimes) {
+            obj.downtimes = message.downtimes.map(e => e ? GenesisDowntimeEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.downtimes = message.downtimes;
+        }
+        obj.last_block_time = message.lastBlockTime ? Timestamp.toAmino(toTimestamp(message.lastBlockTime)) : 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: "/akash.downtimedetector.v1beta1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};

package/esm/akash/downtimedetector/v1beta1/query.js

@@ -0,0 +1,154 @@
+import { Duration } from "../../../google/protobuf/duration";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseRecoveredSinceDowntimeOfLengthRequest() {
+    return {
+        downtime: 0,
+        recovery: Duration.fromPartial({})
+    };
+}
+/**
+ * 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 const RecoveredSinceDowntimeOfLengthRequest = {
+    typeUrl: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.downtime !== 0) {
+            writer.uint32(8).int32(message.downtime);
+        }
+        if (message.recovery !== undefined) {
+            Duration.encode(message.recovery, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseRecoveredSinceDowntimeOfLengthRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.downtime = reader.int32();
+                    break;
+                case 2:
+                    message.recovery = Duration.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRecoveredSinceDowntimeOfLengthRequest();
+        message.downtime = object.downtime ?? 0;
+        message.recovery = object.recovery !== undefined && object.recovery !== null ? Duration.fromPartial(object.recovery) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRecoveredSinceDowntimeOfLengthRequest();
+        if (object.downtime !== undefined && object.downtime !== null) {
+            message.downtime = object.downtime;
+        }
+        if (object.recovery !== undefined && object.recovery !== null) {
+            message.recovery = Duration.fromAmino(object.recovery);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.downtime = message.downtime === 0 ? undefined : message.downtime;
+        obj.recovery = message.recovery ? Duration.toAmino(message.recovery) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RecoveredSinceDowntimeOfLengthRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RecoveredSinceDowntimeOfLengthRequest.decode(message.value);
+    },
+    toProto(message) {
+        return RecoveredSinceDowntimeOfLengthRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthRequest",
+            value: RecoveredSinceDowntimeOfLengthRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseRecoveredSinceDowntimeOfLengthResponse() {
+    return {
+        succesfullyRecovered: false
+    };
+}
+/**
+ * RecoveredSinceDowntimeOfLengthResponse is the response type for the recovery query
+ * @name RecoveredSinceDowntimeOfLengthResponse
+ * @package akash.downtimedetector.v1beta1
+ * @see proto type: akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse
+ */
+export const RecoveredSinceDowntimeOfLengthResponse = {
+    typeUrl: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.succesfullyRecovered === true) {
+            writer.uint32(8).bool(message.succesfullyRecovered);
+        }
+        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 = createBaseRecoveredSinceDowntimeOfLengthResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.succesfullyRecovered = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRecoveredSinceDowntimeOfLengthResponse();
+        message.succesfullyRecovered = object.succesfullyRecovered ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRecoveredSinceDowntimeOfLengthResponse();
+        if (object.succesfully_recovered !== undefined && object.succesfully_recovered !== null) {
+            message.succesfullyRecovered = object.succesfully_recovered;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.succesfully_recovered = message.succesfullyRecovered === false ? undefined : message.succesfullyRecovered;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RecoveredSinceDowntimeOfLengthResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RecoveredSinceDowntimeOfLengthResponse.decode(message.value);
+    },
+    toProto(message) {
+        return RecoveredSinceDowntimeOfLengthResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.downtimedetector.v1beta1.RecoveredSinceDowntimeOfLengthResponse",
+            value: RecoveredSinceDowntimeOfLengthResponse.encode(message).finish()
+        };
+    }
+};

package/esm/akash/downtimedetector/v1beta1/query.lcd.js

@@ -0,0 +1,21 @@
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* RecoveredSinceDowntimeOfLength queries if the chain has recovered for a specified duration
+     since experiencing downtime of a given length */
+    recoveredSinceDowntimeOfLength = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.downtime !== "undefined") {
+            options.params.downtime = params.downtime;
+        }
+        if (typeof params?.recovery !== "undefined") {
+            options.params.recovery = params.recovery;
+        }
+        const endpoint = `akash/downtime-detector/v1beta1/RecoveredSinceDowntimeOfLength`;
+        return await this.req.get(endpoint, options);
+    };
+}

package/esm/akash/downtimedetector/v1beta1/query.rpc.Query.js

@@ -0,0 +1,25 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { RecoveredSinceDowntimeOfLengthRequest, RecoveredSinceDowntimeOfLengthResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* RecoveredSinceDowntimeOfLength queries if the chain has recovered for a specified duration
+     since experiencing downtime of a given length */
+    recoveredSinceDowntimeOfLength = async (request) => {
+        const data = RecoveredSinceDowntimeOfLengthRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.downtimedetector.v1beta1.Query", "RecoveredSinceDowntimeOfLength", data);
+        return promise.then(data => RecoveredSinceDowntimeOfLengthResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        recoveredSinceDowntimeOfLength(request) {
+            return queryService.recoveredSinceDowntimeOfLength(request);
+        }
+    };
+};