@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/blocktime/blocktime.ts

@@ -0,0 +1,203 @@
+import { Timestamp } from "../../google/protobuf/timestamp";
+import { Duration, DurationSDKType } from "../../google/protobuf/duration";
+import * as _m0 from "protobufjs/minimal";
+import { toTimestamp, fromTimestamp, DeepPartial } from "../../helpers";
+/** BlockInfo stores information about a block */
+
+export interface BlockInfo {
+  height: number;
+  timestamp?: Date;
+}
+/** BlockInfo stores information about a block */
+
+export interface BlockInfoSDKType {
+  height: number;
+  timestamp?: Date;
+}
+/** AllDowntimeInfo stores information for all downtime durations. */
+
+export interface AllDowntimeInfo {
+  /**
+   * The downtime information for each tracked duration. Sorted by duration,
+   * ascending. (i.e. the same order as they appear in DowntimeParams).
+   */
+  infos: AllDowntimeInfo_DowntimeInfo[];
+}
+/** AllDowntimeInfo stores information for all downtime durations. */
+
+export interface AllDowntimeInfoSDKType {
+  infos: AllDowntimeInfo_DowntimeInfoSDKType[];
+}
+/**
+ * Stores information about downtime. block_info corresponds to the most
+ * recent block at which a downtime occurred.
+ */
+
+export interface AllDowntimeInfo_DowntimeInfo {
+  duration?: Duration;
+  blockInfo?: BlockInfo;
+}
+/**
+ * Stores information about downtime. block_info corresponds to the most
+ * recent block at which a downtime occurred.
+ */
+
+export interface AllDowntimeInfo_DowntimeInfoSDKType {
+  duration?: DurationSDKType;
+  block_info?: BlockInfoSDKType;
+}
+
+function createBaseBlockInfo(): BlockInfo {
+  return {
+    height: 0,
+    timestamp: undefined
+  };
+}
+
+export const BlockInfo = {
+  encode(message: BlockInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.height !== 0) {
+      writer.uint32(8).uint32(message.height);
+    }
+
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BlockInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.height = reader.uint32();
+          break;
+
+        case 2:
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BlockInfo>): BlockInfo {
+    const message = createBaseBlockInfo();
+    message.height = object.height ?? 0;
+    message.timestamp = object.timestamp ?? undefined;
+    return message;
+  }
+
+};
+
+function createBaseAllDowntimeInfo(): AllDowntimeInfo {
+  return {
+    infos: []
+  };
+}
+
+export const AllDowntimeInfo = {
+  encode(message: AllDowntimeInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.infos) {
+      AllDowntimeInfo_DowntimeInfo.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AllDowntimeInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAllDowntimeInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.infos.push(AllDowntimeInfo_DowntimeInfo.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<AllDowntimeInfo>): AllDowntimeInfo {
+    const message = createBaseAllDowntimeInfo();
+    message.infos = object.infos?.map(e => AllDowntimeInfo_DowntimeInfo.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseAllDowntimeInfo_DowntimeInfo(): AllDowntimeInfo_DowntimeInfo {
+  return {
+    duration: undefined,
+    blockInfo: undefined
+  };
+}
+
+export const AllDowntimeInfo_DowntimeInfo = {
+  encode(message: AllDowntimeInfo_DowntimeInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.duration !== undefined) {
+      Duration.encode(message.duration, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.blockInfo !== undefined) {
+      BlockInfo.encode(message.blockInfo, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AllDowntimeInfo_DowntimeInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAllDowntimeInfo_DowntimeInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.duration = Duration.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.blockInfo = BlockInfo.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<AllDowntimeInfo_DowntimeInfo>): AllDowntimeInfo_DowntimeInfo {
+    const message = createBaseAllDowntimeInfo_DowntimeInfo();
+    message.duration = object.duration !== undefined && object.duration !== null ? Duration.fromPartial(object.duration) : undefined;
+    message.blockInfo = object.blockInfo !== undefined && object.blockInfo !== null ? BlockInfo.fromPartial(object.blockInfo) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/zogux/blocktime/genesis.ts

@@ -0,0 +1,58 @@
+import { DowntimeParams, DowntimeParamsSDKType } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the blocktime module's genesis state. */
+
+export interface GenesisState {
+  params?: DowntimeParams;
+}
+/** GenesisState defines the blocktime module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: DowntimeParamsSDKType;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      DowntimeParams.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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 = DowntimeParams.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? DowntimeParams.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/zogux/blocktime/params.ts

@@ -0,0 +1,125 @@
+import { Duration, DurationSDKType } from "../../google/protobuf/duration";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** DowntimeParams defines the parameters for downtime. */
+
+export interface DowntimeParams {
+  /**
+   * Durations tracked for downtime. The durations must be sorted from
+   * shortest to longest and must all be positive.
+   */
+  durations: Duration[];
+}
+/** DowntimeParams defines the parameters for downtime. */
+
+export interface DowntimeParamsSDKType {
+  durations: DurationSDKType[];
+}
+/** SynchronyParams defines the parameters for block synchrony. */
+
+export interface SynchronyParams {
+  /**
+   * next_block_delay replaces the locally configured timeout_commit in
+   * CometBFT. It determines the amount of time the CometBFT waits after the
+   * `CommitTime` (subjective time when +2/3 precommits were received), before
+   * moving to next height.
+   * If the application sends next_block_delay = 0 to the consensus engine, the
+   * latter defaults back to using timeout_commit.
+   */
+  nextBlockDelay?: Duration;
+}
+/** SynchronyParams defines the parameters for block synchrony. */
+
+export interface SynchronyParamsSDKType {
+  next_block_delay?: DurationSDKType;
+}
+
+function createBaseDowntimeParams(): DowntimeParams {
+  return {
+    durations: []
+  };
+}
+
+export const DowntimeParams = {
+  encode(message: DowntimeParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.durations) {
+      Duration.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DowntimeParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDowntimeParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.durations.push(Duration.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<DowntimeParams>): DowntimeParams {
+    const message = createBaseDowntimeParams();
+    message.durations = object.durations?.map(e => Duration.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseSynchronyParams(): SynchronyParams {
+  return {
+    nextBlockDelay: undefined
+  };
+}
+
+export const SynchronyParams = {
+  encode(message: SynchronyParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.nextBlockDelay !== undefined) {
+      Duration.encode(message.nextBlockDelay, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SynchronyParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSynchronyParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.nextBlockDelay = Duration.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SynchronyParams>): SynchronyParams {
+    const message = createBaseSynchronyParams();
+    message.nextBlockDelay = object.nextBlockDelay !== undefined && object.nextBlockDelay !== null ? Duration.fromPartial(object.nextBlockDelay) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/zogux/blocktime/query.lcd.ts

@@ -0,0 +1,38 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryDowntimeParamsRequest, QueryDowntimeParamsResponseSDKType, QueryAllDowntimeInfoRequest, QueryAllDowntimeInfoResponseSDKType, QuerySynchronyParamsRequest, QuerySynchronyParamsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.downtimeParams = this.downtimeParams.bind(this);
+    this.allDowntimeInfo = this.allDowntimeInfo.bind(this);
+    this.synchronyParams = this.synchronyParams.bind(this);
+  }
+  /* Queries the DowntimeParams. */
+
+
+  async downtimeParams(_params: QueryDowntimeParamsRequest = {}): Promise<QueryDowntimeParamsResponseSDKType> {
+    const endpoint = `zogux/v4/blocktime/downtime_params`;
+    return await this.req.get<QueryDowntimeParamsResponseSDKType>(endpoint);
+  }
+  /* Queries all recorded downtime info. */
+
+
+  async allDowntimeInfo(_params: QueryAllDowntimeInfoRequest = {}): Promise<QueryAllDowntimeInfoResponseSDKType> {
+    const endpoint = `zogux/v4/blocktime/all_downtime_info`;
+    return await this.req.get<QueryAllDowntimeInfoResponseSDKType>(endpoint);
+  }
+  /* Queries the SynchronyParams. */
+
+
+  async synchronyParams(_params: QuerySynchronyParamsRequest = {}): Promise<QuerySynchronyParamsResponseSDKType> {
+    const endpoint = `zogux/v4/blocktime/synchrony_params`;
+    return await this.req.get<QuerySynchronyParamsResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/zogux/blocktime/query.rpc.Query.ts

@@ -0,0 +1,77 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryDowntimeParamsRequest, QueryDowntimeParamsResponse, QueryPreviousBlockInfoRequest, QueryPreviousBlockInfoResponse, QueryAllDowntimeInfoRequest, QueryAllDowntimeInfoResponse, QuerySynchronyParamsRequest, QuerySynchronyParamsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Queries the DowntimeParams. */
+  downtimeParams(request?: QueryDowntimeParamsRequest): Promise<QueryDowntimeParamsResponse>;
+  /** Queries the information of the previous block */
+
+  previousBlockInfo(request?: QueryPreviousBlockInfoRequest): Promise<QueryPreviousBlockInfoResponse>;
+  /** Queries all recorded downtime info. */
+
+  allDowntimeInfo(request?: QueryAllDowntimeInfoRequest): Promise<QueryAllDowntimeInfoResponse>;
+  /** Queries the SynchronyParams. */
+
+  synchronyParams(request?: QuerySynchronyParamsRequest): Promise<QuerySynchronyParamsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.downtimeParams = this.downtimeParams.bind(this);
+    this.previousBlockInfo = this.previousBlockInfo.bind(this);
+    this.allDowntimeInfo = this.allDowntimeInfo.bind(this);
+    this.synchronyParams = this.synchronyParams.bind(this);
+  }
+
+  downtimeParams(request: QueryDowntimeParamsRequest = {}): Promise<QueryDowntimeParamsResponse> {
+    const data = QueryDowntimeParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.blocktime.Query", "DowntimeParams", data);
+    return promise.then(data => QueryDowntimeParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  previousBlockInfo(request: QueryPreviousBlockInfoRequest = {}): Promise<QueryPreviousBlockInfoResponse> {
+    const data = QueryPreviousBlockInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.blocktime.Query", "PreviousBlockInfo", data);
+    return promise.then(data => QueryPreviousBlockInfoResponse.decode(new _m0.Reader(data)));
+  }
+
+  allDowntimeInfo(request: QueryAllDowntimeInfoRequest = {}): Promise<QueryAllDowntimeInfoResponse> {
+    const data = QueryAllDowntimeInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.blocktime.Query", "AllDowntimeInfo", data);
+    return promise.then(data => QueryAllDowntimeInfoResponse.decode(new _m0.Reader(data)));
+  }
+
+  synchronyParams(request: QuerySynchronyParamsRequest = {}): Promise<QuerySynchronyParamsResponse> {
+    const data = QuerySynchronyParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.blocktime.Query", "SynchronyParams", data);
+    return promise.then(data => QuerySynchronyParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    downtimeParams(request?: QueryDowntimeParamsRequest): Promise<QueryDowntimeParamsResponse> {
+      return queryService.downtimeParams(request);
+    },
+
+    previousBlockInfo(request?: QueryPreviousBlockInfoRequest): Promise<QueryPreviousBlockInfoResponse> {
+      return queryService.previousBlockInfo(request);
+    },
+
+    allDowntimeInfo(request?: QueryAllDowntimeInfoRequest): Promise<QueryAllDowntimeInfoResponse> {
+      return queryService.allDowntimeInfo(request);
+    },
+
+    synchronyParams(request?: QuerySynchronyParamsRequest): Promise<QuerySynchronyParamsResponse> {
+      return queryService.synchronyParams(request);
+    }
+
+  };
+};