@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/epochs/epoch_info.ts

@@ -0,0 +1,167 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** EpochInfo stores metadata of an epoch timer. */
+
+export interface EpochInfo {
+  /** name is the unique identifier. */
+  name: string;
+  /**
+   * next_tick indicates when the next epoch starts (in Unix Epoch seconds),
+   * if `EpochInfo` has been initialized.
+   * If `EpochInfo` is not initialized yet, `next_tick` indicates the earliest
+   * initialization time (see `is_initialized` below).
+   */
+
+  nextTick: number;
+  /** duration of the epoch in seconds. */
+
+  duration: number;
+  /**
+   * current epoch is the number of the current epoch.
+   * 0 if `next_tick` has never been reached, positive otherwise.
+   */
+
+  currentEpoch: number;
+  /**
+   * current_epoch_start_block indicates the block height when the current
+   * epoch started. 0 if `current_epoch` is 0.
+   */
+
+  currentEpochStartBlock: number;
+  /**
+   * is_initialized indicates whether the `EpochInfo` has been initialized
+   * and started ticking.
+   * An `EpochInfo` is initialized when all below conditions are true:
+   * - Not yet initialized
+   * - `EthBlockHeight` >= 2
+   * - `BlockTime` >= `next_tick`
+   */
+
+  isInitialized: boolean;
+  /**
+   * fast_forward_next_tick specifies whether during initialization, `next_tick`
+   * should be fast-forwarded to be greater than the current block time.
+   * If `false`, the original `next_tick` value is
+   * unchanged during initialization.
+   * If `true`, `next_tick` will be set to the smallest value `x` greater than
+   * the current block time such that `(x - next_tick) % duration = 0`.
+   */
+
+  fastForwardNextTick: boolean;
+}
+/** EpochInfo stores metadata of an epoch timer. */
+
+export interface EpochInfoSDKType {
+  name: string;
+  next_tick: number;
+  duration: number;
+  current_epoch: number;
+  current_epoch_start_block: number;
+  is_initialized: boolean;
+  fast_forward_next_tick: boolean;
+}
+
+function createBaseEpochInfo(): EpochInfo {
+  return {
+    name: "",
+    nextTick: 0,
+    duration: 0,
+    currentEpoch: 0,
+    currentEpochStartBlock: 0,
+    isInitialized: false,
+    fastForwardNextTick: false
+  };
+}
+
+export const EpochInfo = {
+  encode(message: EpochInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+
+    if (message.nextTick !== 0) {
+      writer.uint32(16).uint32(message.nextTick);
+    }
+
+    if (message.duration !== 0) {
+      writer.uint32(24).uint32(message.duration);
+    }
+
+    if (message.currentEpoch !== 0) {
+      writer.uint32(32).uint32(message.currentEpoch);
+    }
+
+    if (message.currentEpochStartBlock !== 0) {
+      writer.uint32(40).uint32(message.currentEpochStartBlock);
+    }
+
+    if (message.isInitialized === true) {
+      writer.uint32(48).bool(message.isInitialized);
+    }
+
+    if (message.fastForwardNextTick === true) {
+      writer.uint32(56).bool(message.fastForwardNextTick);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EpochInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEpochInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+
+        case 2:
+          message.nextTick = reader.uint32();
+          break;
+
+        case 3:
+          message.duration = reader.uint32();
+          break;
+
+        case 4:
+          message.currentEpoch = reader.uint32();
+          break;
+
+        case 5:
+          message.currentEpochStartBlock = reader.uint32();
+          break;
+
+        case 6:
+          message.isInitialized = reader.bool();
+          break;
+
+        case 7:
+          message.fastForwardNextTick = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<EpochInfo>): EpochInfo {
+    const message = createBaseEpochInfo();
+    message.name = object.name ?? "";
+    message.nextTick = object.nextTick ?? 0;
+    message.duration = object.duration ?? 0;
+    message.currentEpoch = object.currentEpoch ?? 0;
+    message.currentEpochStartBlock = object.currentEpochStartBlock ?? 0;
+    message.isInitialized = object.isInitialized ?? false;
+    message.fastForwardNextTick = object.fastForwardNextTick ?? false;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,58 @@
+import { EpochInfo, EpochInfoSDKType } from "./epoch_info";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the epochs module's genesis state. */
+
+export interface GenesisState {
+  epochInfoList: EpochInfo[];
+}
+/** GenesisState defines the epochs module's genesis state. */
+
+export interface GenesisStateSDKType {
+  epoch_info_list: EpochInfoSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    epochInfoList: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.epochInfoList) {
+      EpochInfo.encode(v!, 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.epochInfoList.push(EpochInfo.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.epochInfoList = object.epochInfoList?.map(e => EpochInfo.fromPartial(e)) || [];
+    return message;
+  }
+
+};

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

@@ -0,0 +1,41 @@
+import { setPaginationParams } from "../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryGetEpochInfoRequest, QueryEpochInfoResponseSDKType, QueryAllEpochInfoRequest, QueryEpochInfoAllResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.epochInfo = this.epochInfo.bind(this);
+    this.epochInfoAll = this.epochInfoAll.bind(this);
+  }
+  /* Queries a EpochInfo by name. */
+
+
+  async epochInfo(params: QueryGetEpochInfoRequest): Promise<QueryEpochInfoResponseSDKType> {
+    const endpoint = `zogux/v4/epochs/epoch_info/${params.name}`;
+    return await this.req.get<QueryEpochInfoResponseSDKType>(endpoint);
+  }
+  /* Queries a list of EpochInfo items. */
+
+
+  async epochInfoAll(params: QueryAllEpochInfoRequest = {
+    pagination: undefined
+  }): Promise<QueryEpochInfoAllResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `zogux/v4/epochs/epoch_info`;
+    return await this.req.get<QueryEpochInfoAllResponseSDKType>(endpoint, options);
+  }
+
+}

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

@@ -0,0 +1,51 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryGetEpochInfoRequest, QueryEpochInfoResponse, QueryAllEpochInfoRequest, QueryEpochInfoAllResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Queries a EpochInfo by name. */
+  epochInfo(request: QueryGetEpochInfoRequest): Promise<QueryEpochInfoResponse>;
+  /** Queries a list of EpochInfo items. */
+
+  epochInfoAll(request?: QueryAllEpochInfoRequest): Promise<QueryEpochInfoAllResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.epochInfo = this.epochInfo.bind(this);
+    this.epochInfoAll = this.epochInfoAll.bind(this);
+  }
+
+  epochInfo(request: QueryGetEpochInfoRequest): Promise<QueryEpochInfoResponse> {
+    const data = QueryGetEpochInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.epochs.Query", "EpochInfo", data);
+    return promise.then(data => QueryEpochInfoResponse.decode(new _m0.Reader(data)));
+  }
+
+  epochInfoAll(request: QueryAllEpochInfoRequest = {
+    pagination: undefined
+  }): Promise<QueryEpochInfoAllResponse> {
+    const data = QueryAllEpochInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.epochs.Query", "EpochInfoAll", data);
+    return promise.then(data => QueryEpochInfoAllResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    epochInfo(request: QueryGetEpochInfoRequest): Promise<QueryEpochInfoResponse> {
+      return queryService.epochInfo(request);
+    },
+
+    epochInfoAll(request?: QueryAllEpochInfoRequest): Promise<QueryEpochInfoAllResponse> {
+      return queryService.epochInfoAll(request);
+    }
+
+  };
+};

package/src/codegen/zogux/epochs/query.ts

@@ -0,0 +1,237 @@
+import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../cosmos/base/query/v1beta1/pagination";
+import { EpochInfo, EpochInfoSDKType } from "./epoch_info";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** QueryGetEpochInfoRequest is request type for the GetEpochInfo RPC method. */
+
+export interface QueryGetEpochInfoRequest {
+  /** QueryGetEpochInfoRequest is request type for the GetEpochInfo RPC method. */
+  name: string;
+}
+/** QueryGetEpochInfoRequest is request type for the GetEpochInfo RPC method. */
+
+export interface QueryGetEpochInfoRequestSDKType {
+  name: string;
+}
+/** QueryEpochInfoResponse is response type for the GetEpochInfo RPC method. */
+
+export interface QueryEpochInfoResponse {
+  epochInfo?: EpochInfo;
+}
+/** QueryEpochInfoResponse is response type for the GetEpochInfo RPC method. */
+
+export interface QueryEpochInfoResponseSDKType {
+  epoch_info?: EpochInfoSDKType;
+}
+/** QueryAllEpochInfoRequest is request type for the AllEpochInfo RPC method. */
+
+export interface QueryAllEpochInfoRequest {
+  pagination?: PageRequest;
+}
+/** QueryAllEpochInfoRequest is request type for the AllEpochInfo RPC method. */
+
+export interface QueryAllEpochInfoRequestSDKType {
+  pagination?: PageRequestSDKType;
+}
+/** QueryEpochInfoAllResponse is response type for the AllEpochInfo RPC method. */
+
+export interface QueryEpochInfoAllResponse {
+  epochInfo: EpochInfo[];
+  pagination?: PageResponse;
+}
+/** QueryEpochInfoAllResponse is response type for the AllEpochInfo RPC method. */
+
+export interface QueryEpochInfoAllResponseSDKType {
+  epoch_info: EpochInfoSDKType[];
+  pagination?: PageResponseSDKType;
+}
+
+function createBaseQueryGetEpochInfoRequest(): QueryGetEpochInfoRequest {
+  return {
+    name: ""
+  };
+}
+
+export const QueryGetEpochInfoRequest = {
+  encode(message: QueryGetEpochInfoRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetEpochInfoRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGetEpochInfoRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryGetEpochInfoRequest>): QueryGetEpochInfoRequest {
+    const message = createBaseQueryGetEpochInfoRequest();
+    message.name = object.name ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryEpochInfoResponse(): QueryEpochInfoResponse {
+  return {
+    epochInfo: undefined
+  };
+}
+
+export const QueryEpochInfoResponse = {
+  encode(message: QueryEpochInfoResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.epochInfo !== undefined) {
+      EpochInfo.encode(message.epochInfo, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryEpochInfoResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEpochInfoResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.epochInfo = EpochInfo.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryEpochInfoResponse>): QueryEpochInfoResponse {
+    const message = createBaseQueryEpochInfoResponse();
+    message.epochInfo = object.epochInfo !== undefined && object.epochInfo !== null ? EpochInfo.fromPartial(object.epochInfo) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryAllEpochInfoRequest(): QueryAllEpochInfoRequest {
+  return {
+    pagination: undefined
+  };
+}
+
+export const QueryAllEpochInfoRequest = {
+  encode(message: QueryAllEpochInfoRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllEpochInfoRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllEpochInfoRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryAllEpochInfoRequest>): QueryAllEpochInfoRequest {
+    const message = createBaseQueryAllEpochInfoRequest();
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryEpochInfoAllResponse(): QueryEpochInfoAllResponse {
+  return {
+    epochInfo: [],
+    pagination: undefined
+  };
+}
+
+export const QueryEpochInfoAllResponse = {
+  encode(message: QueryEpochInfoAllResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.epochInfo) {
+      EpochInfo.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryEpochInfoAllResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEpochInfoAllResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.epochInfo.push(EpochInfo.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryEpochInfoAllResponse>): QueryEpochInfoAllResponse {
+    const message = createBaseQueryEpochInfoAllResponse();
+    message.epochInfo = object.epochInfo?.map(e => EpochInfo.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,74 @@
+import { PerpetualFeeParams, PerpetualFeeParamsSDKType } from "./params";
+import { StakingTier, StakingTierSDKType } from "./staking_tier";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the feetiers module's genesis state. */
+
+export interface GenesisState {
+  /** The parameters for perpetual fees. */
+  params?: PerpetualFeeParams;
+  /** The staking tiers. */
+
+  stakingTiers: StakingTier[];
+}
+/** GenesisState defines the feetiers module's genesis state. */
+
+export interface GenesisStateSDKType {
+  params?: PerpetualFeeParamsSDKType;
+  staking_tiers: StakingTierSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: undefined,
+    stakingTiers: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      PerpetualFeeParams.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.stakingTiers) {
+      StakingTier.encode(v!, writer.uint32(18).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 = PerpetualFeeParams.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.stakingTiers.push(StakingTier.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 ? PerpetualFeeParams.fromPartial(object.params) : undefined;
+    message.stakingTiers = object.stakingTiers?.map(e => StakingTier.fromPartial(e)) || [];
+    return message;
+  }
+
+};