@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/ratelimit/limit_params.ts

@@ -0,0 +1,174 @@
+import { Duration, DurationSDKType } from "../../google/protobuf/duration";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** LimitParams defines rate limit params on a denom. */
+
+export interface LimitParams {
+  /**
+   * denom is the denomination of the token being rate limited.
+   * e.g. ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5
+   */
+  denom: string;
+  /**
+   * limiters is a list of rate-limiters on this denom. All limiters
+   * must be satified for a withdrawal to proceed.
+   */
+
+  limiters: Limiter[];
+}
+/** LimitParams defines rate limit params on a denom. */
+
+export interface LimitParamsSDKType {
+  denom: string;
+  limiters: LimiterSDKType[];
+}
+/** Limiter defines one rate-limiter on a specfic denom. */
+
+export interface Limiter {
+  /**
+   * period is the rolling time period for which the limit applies
+   * e.g. 3600 (an hour)
+   */
+  period?: Duration;
+  /**
+   * baseline_minimum is the minimum maximum withdrawal coin amount within the
+   * time period.
+   * e.g. 100_000_000_000 uusdc for 100k USDC; 5e22 azo for 50k ZOTN
+   */
+
+  baselineMinimum: Uint8Array;
+  /**
+   * baseline_tvl_ppm is the maximum ratio of TVL withdrawable in
+   * the time period, in part-per-million.
+   * e.g. 100_000 (10%)
+   */
+
+  baselineTvlPpm: number;
+}
+/** Limiter defines one rate-limiter on a specfic denom. */
+
+export interface LimiterSDKType {
+  period?: DurationSDKType;
+  baseline_minimum: Uint8Array;
+  baseline_tvl_ppm: number;
+}
+
+function createBaseLimitParams(): LimitParams {
+  return {
+    denom: "",
+    limiters: []
+  };
+}
+
+export const LimitParams = {
+  encode(message: LimitParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+
+    for (const v of message.limiters) {
+      Limiter.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LimitParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLimitParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+
+        case 2:
+          message.limiters.push(Limiter.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LimitParams>): LimitParams {
+    const message = createBaseLimitParams();
+    message.denom = object.denom ?? "";
+    message.limiters = object.limiters?.map(e => Limiter.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseLimiter(): Limiter {
+  return {
+    period: undefined,
+    baselineMinimum: new Uint8Array(),
+    baselineTvlPpm: 0
+  };
+}
+
+export const Limiter = {
+  encode(message: Limiter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.period !== undefined) {
+      Duration.encode(message.period, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.baselineMinimum.length !== 0) {
+      writer.uint32(26).bytes(message.baselineMinimum);
+    }
+
+    if (message.baselineTvlPpm !== 0) {
+      writer.uint32(32).uint32(message.baselineTvlPpm);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Limiter {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLimiter();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.period = Duration.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.baselineMinimum = reader.bytes();
+          break;
+
+        case 4:
+          message.baselineTvlPpm = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Limiter>): Limiter {
+    const message = createBaseLimiter();
+    message.period = object.period !== undefined && object.period !== null ? Duration.fromPartial(object.period) : undefined;
+    message.baselineMinimum = object.baselineMinimum ?? new Uint8Array();
+    message.baselineTvlPpm = object.baselineTvlPpm ?? 0;
+    return message;
+  }
+
+};

package/src/codegen/zogux/ratelimit/pending_send_packet.ts

@@ -0,0 +1,75 @@
+import { Long, DeepPartial } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * PendingSendPacket contains the channel_id and sequence pair to identify a
+ * pending packet
+ */
+
+export interface PendingSendPacket {
+  channelId: string;
+  sequence: Long;
+}
+/**
+ * PendingSendPacket contains the channel_id and sequence pair to identify a
+ * pending packet
+ */
+
+export interface PendingSendPacketSDKType {
+  channel_id: string;
+  sequence: Long;
+}
+
+function createBasePendingSendPacket(): PendingSendPacket {
+  return {
+    channelId: "",
+    sequence: Long.UZERO
+  };
+}
+
+export const PendingSendPacket = {
+  encode(message: PendingSendPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.channelId !== "") {
+      writer.uint32(10).string(message.channelId);
+    }
+
+    if (!message.sequence.isZero()) {
+      writer.uint32(16).uint64(message.sequence);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PendingSendPacket {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePendingSendPacket();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.channelId = reader.string();
+          break;
+
+        case 2:
+          message.sequence = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PendingSendPacket>): PendingSendPacket {
+    const message = createBasePendingSendPacket();
+    message.channelId = object.channelId ?? "";
+    message.sequence = object.sequence !== undefined && object.sequence !== null ? Long.fromValue(object.sequence) : Long.UZERO;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,46 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { ListLimitParamsRequest, ListLimitParamsResponseSDKType, QueryCapacityByDenomRequest, QueryCapacityByDenomResponseSDKType, QueryAllPendingSendPacketsRequest, QueryAllPendingSendPacketsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.listLimitParams = this.listLimitParams.bind(this);
+    this.capacityByDenom = this.capacityByDenom.bind(this);
+    this.allPendingSendPackets = this.allPendingSendPackets.bind(this);
+  }
+  /* List all limit params. */
+
+
+  async listLimitParams(_params: ListLimitParamsRequest = {}): Promise<ListLimitParamsResponseSDKType> {
+    const endpoint = `zogux/v4/ratelimit/list_limit_params`;
+    return await this.req.get<ListLimitParamsResponseSDKType>(endpoint);
+  }
+  /* Query capacity by denom. */
+
+
+  async capacityByDenom(params: QueryCapacityByDenomRequest): Promise<QueryCapacityByDenomResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+
+    const endpoint = `zogux/v4/ratelimit/capacity_by_denom`;
+    return await this.req.get<QueryCapacityByDenomResponseSDKType>(endpoint, options);
+  }
+  /* Get all pending send packets */
+
+
+  async allPendingSendPackets(_params: QueryAllPendingSendPacketsRequest = {}): Promise<QueryAllPendingSendPacketsResponseSDKType> {
+    const endpoint = `zogux/v4/ratelimit/get_all_pending_send_packet`;
+    return await this.req.get<QueryAllPendingSendPacketsResponseSDKType>(endpoint);
+  }
+
+}

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

@@ -0,0 +1,63 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { ListLimitParamsRequest, ListLimitParamsResponse, QueryCapacityByDenomRequest, QueryCapacityByDenomResponse, QueryAllPendingSendPacketsRequest, QueryAllPendingSendPacketsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** List all limit params. */
+  listLimitParams(request?: ListLimitParamsRequest): Promise<ListLimitParamsResponse>;
+  /** Query capacity by denom. */
+
+  capacityByDenom(request: QueryCapacityByDenomRequest): Promise<QueryCapacityByDenomResponse>;
+  /** Get all pending send packets */
+
+  allPendingSendPackets(request?: QueryAllPendingSendPacketsRequest): Promise<QueryAllPendingSendPacketsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.listLimitParams = this.listLimitParams.bind(this);
+    this.capacityByDenom = this.capacityByDenom.bind(this);
+    this.allPendingSendPackets = this.allPendingSendPackets.bind(this);
+  }
+
+  listLimitParams(request: ListLimitParamsRequest = {}): Promise<ListLimitParamsResponse> {
+    const data = ListLimitParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.ratelimit.Query", "ListLimitParams", data);
+    return promise.then(data => ListLimitParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  capacityByDenom(request: QueryCapacityByDenomRequest): Promise<QueryCapacityByDenomResponse> {
+    const data = QueryCapacityByDenomRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.ratelimit.Query", "CapacityByDenom", data);
+    return promise.then(data => QueryCapacityByDenomResponse.decode(new _m0.Reader(data)));
+  }
+
+  allPendingSendPackets(request: QueryAllPendingSendPacketsRequest = {}): Promise<QueryAllPendingSendPacketsResponse> {
+    const data = QueryAllPendingSendPacketsRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.ratelimit.Query", "AllPendingSendPackets", data);
+    return promise.then(data => QueryAllPendingSendPacketsResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    listLimitParams(request?: ListLimitParamsRequest): Promise<ListLimitParamsResponse> {
+      return queryService.listLimitParams(request);
+    },
+
+    capacityByDenom(request: QueryCapacityByDenomRequest): Promise<QueryCapacityByDenomResponse> {
+      return queryService.capacityByDenom(request);
+    },
+
+    allPendingSendPackets(request?: QueryAllPendingSendPacketsRequest): Promise<QueryAllPendingSendPacketsResponse> {
+      return queryService.allPendingSendPackets(request);
+    }
+
+  };
+};

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

@@ -0,0 +1,333 @@
+import { LimitParams, LimitParamsSDKType } from "./limit_params";
+import { LimiterCapacity, LimiterCapacitySDKType } from "./capacity";
+import { PendingSendPacket, PendingSendPacketSDKType } from "./pending_send_packet";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** ListLimitParamsRequest is a request type of the ListLimitParams RPC method. */
+
+export interface ListLimitParamsRequest {}
+/** ListLimitParamsRequest is a request type of the ListLimitParams RPC method. */
+
+export interface ListLimitParamsRequestSDKType {}
+/** ListLimitParamsResponse is a response type of the ListLimitParams RPC method. */
+
+export interface ListLimitParamsResponse {
+  limitParamsList: LimitParams[];
+}
+/** ListLimitParamsResponse is a response type of the ListLimitParams RPC method. */
+
+export interface ListLimitParamsResponseSDKType {
+  limit_params_list: LimitParamsSDKType[];
+}
+/**
+ * QueryCapacityByDenomRequest is a request type for the CapacityByDenom RPC
+ * method.
+ */
+
+export interface QueryCapacityByDenomRequest {
+  /**
+   * QueryCapacityByDenomRequest is a request type for the CapacityByDenom RPC
+   * method.
+   */
+  denom: string;
+}
+/**
+ * QueryCapacityByDenomRequest is a request type for the CapacityByDenom RPC
+ * method.
+ */
+
+export interface QueryCapacityByDenomRequestSDKType {
+  denom: string;
+}
+/**
+ * QueryCapacityByDenomResponse is a response type of the CapacityByDenom RPC
+ * method.
+ */
+
+export interface QueryCapacityByDenomResponse {
+  limiterCapacityList: LimiterCapacity[];
+}
+/**
+ * QueryCapacityByDenomResponse is a response type of the CapacityByDenom RPC
+ * method.
+ */
+
+export interface QueryCapacityByDenomResponseSDKType {
+  limiter_capacity_list: LimiterCapacitySDKType[];
+}
+/**
+ * QueryAllPendingSendPacketsRequest is a request type for the
+ * AllPendingSendPackets RPC
+ */
+
+export interface QueryAllPendingSendPacketsRequest {}
+/**
+ * QueryAllPendingSendPacketsRequest is a request type for the
+ * AllPendingSendPackets RPC
+ */
+
+export interface QueryAllPendingSendPacketsRequestSDKType {}
+/**
+ * QueryAllPendingSendPacketsResponse is a response type of the
+ * AllPendingSendPackets RPC
+ */
+
+export interface QueryAllPendingSendPacketsResponse {
+  pendingSendPackets: PendingSendPacket[];
+}
+/**
+ * QueryAllPendingSendPacketsResponse is a response type of the
+ * AllPendingSendPackets RPC
+ */
+
+export interface QueryAllPendingSendPacketsResponseSDKType {
+  pending_send_packets: PendingSendPacketSDKType[];
+}
+
+function createBaseListLimitParamsRequest(): ListLimitParamsRequest {
+  return {};
+}
+
+export const ListLimitParamsRequest = {
+  encode(_: ListLimitParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListLimitParamsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListLimitParamsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<ListLimitParamsRequest>): ListLimitParamsRequest {
+    const message = createBaseListLimitParamsRequest();
+    return message;
+  }
+
+};
+
+function createBaseListLimitParamsResponse(): ListLimitParamsResponse {
+  return {
+    limitParamsList: []
+  };
+}
+
+export const ListLimitParamsResponse = {
+  encode(message: ListLimitParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.limitParamsList) {
+      LimitParams.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListLimitParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListLimitParamsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.limitParamsList.push(LimitParams.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ListLimitParamsResponse>): ListLimitParamsResponse {
+    const message = createBaseListLimitParamsResponse();
+    message.limitParamsList = object.limitParamsList?.map(e => LimitParams.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseQueryCapacityByDenomRequest(): QueryCapacityByDenomRequest {
+  return {
+    denom: ""
+  };
+}
+
+export const QueryCapacityByDenomRequest = {
+  encode(message: QueryCapacityByDenomRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryCapacityByDenomRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryCapacityByDenomRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryCapacityByDenomRequest>): QueryCapacityByDenomRequest {
+    const message = createBaseQueryCapacityByDenomRequest();
+    message.denom = object.denom ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryCapacityByDenomResponse(): QueryCapacityByDenomResponse {
+  return {
+    limiterCapacityList: []
+  };
+}
+
+export const QueryCapacityByDenomResponse = {
+  encode(message: QueryCapacityByDenomResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.limiterCapacityList) {
+      LimiterCapacity.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryCapacityByDenomResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryCapacityByDenomResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.limiterCapacityList.push(LimiterCapacity.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryCapacityByDenomResponse>): QueryCapacityByDenomResponse {
+    const message = createBaseQueryCapacityByDenomResponse();
+    message.limiterCapacityList = object.limiterCapacityList?.map(e => LimiterCapacity.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseQueryAllPendingSendPacketsRequest(): QueryAllPendingSendPacketsRequest {
+  return {};
+}
+
+export const QueryAllPendingSendPacketsRequest = {
+  encode(_: QueryAllPendingSendPacketsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllPendingSendPacketsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllPendingSendPacketsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<QueryAllPendingSendPacketsRequest>): QueryAllPendingSendPacketsRequest {
+    const message = createBaseQueryAllPendingSendPacketsRequest();
+    return message;
+  }
+
+};
+
+function createBaseQueryAllPendingSendPacketsResponse(): QueryAllPendingSendPacketsResponse {
+  return {
+    pendingSendPackets: []
+  };
+}
+
+export const QueryAllPendingSendPacketsResponse = {
+  encode(message: QueryAllPendingSendPacketsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.pendingSendPackets) {
+      PendingSendPacket.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllPendingSendPacketsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllPendingSendPacketsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.pendingSendPackets.push(PendingSendPacket.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryAllPendingSendPacketsResponse>): QueryAllPendingSendPacketsResponse {
+    const message = createBaseQueryAllPendingSendPacketsResponse();
+    message.pendingSendPackets = object.pendingSendPackets?.map(e => PendingSendPacket.fromPartial(e)) || [];
+    return message;
+  }
+
+};