@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/clob/order_removals.ts

@@ -0,0 +1,228 @@
+import { OrderId, OrderIdSDKType } from "./order";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+export enum OrderRemoval_RemovalReason {
+  /**
+   * REMOVAL_REASON_UNSPECIFIED - REMOVAL_REASON_UNSPECIFIED represents an unspecified removal reason. This
+   * removal reason is used as a catchall and should never appear on an
+   * OrderRemoval in the operations queue.
+   */
+  REMOVAL_REASON_UNSPECIFIED = 0,
+
+  /**
+   * REMOVAL_REASON_UNDERCOLLATERALIZED - REMOVAL_REASON_UNDERCOLLATERALIZED represents a removal of an order which
+   * if filled in isolation with respect to the current state of the
+   * subaccount would leave the subaccount undercollateralized.
+   */
+  REMOVAL_REASON_UNDERCOLLATERALIZED = 1,
+
+  /**
+   * REMOVAL_REASON_INVALID_REDUCE_ONLY - REMOVAL_REASON_INVALID_REDUCE_ONLY represents a removal of a reduce-only
+   * order which if filled in isolation with respect to the current state of
+   * the subaccount would cause the subaccount's existing position to increase
+   * or change sides.
+   */
+  REMOVAL_REASON_INVALID_REDUCE_ONLY = 2,
+
+  /**
+   * REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER - REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER represents a removal of
+   * a stateful post-only order that was deemed invalid because it crossed
+   * maker orders on the book of the proposer.
+   */
+  REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER = 3,
+
+  /**
+   * REMOVAL_REASON_INVALID_SELF_TRADE - REMOVAL_REASON_INVALID_SELF_TRADE represents a removal of a stateful
+   * order that was deemed invalid because it constituted a self trade on the
+   * proposers orderbook.
+   */
+  REMOVAL_REASON_INVALID_SELF_TRADE = 4,
+
+  /**
+   * REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED - REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED represents a
+   * removal of a conditional FOK order that was deemed invalid because it
+   * could not be completely filled. Conditional FOK orders should always be
+   * fully-filled or removed in the block after they are triggered.
+   */
+  REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED = 5,
+
+  /**
+   * REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK - REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK represents a removal
+   * of a conditional IOC order.
+   * Conditional IOC orders should always have their remaining size removed
+   * in the block after they are triggered.
+   */
+  REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK = 6,
+
+  /**
+   * REMOVAL_REASON_FULLY_FILLED - REMOVAL_REASON_FULLY_FILLED represents a removal of an order that
+   * was fully filled and should therefore be removed from state.
+   */
+  REMOVAL_REASON_FULLY_FILLED = 7,
+
+  /**
+   * REMOVAL_REASON_VIOLATES_ISOLATED_SUBACCOUNT_CONSTRAINTS - REMOVAL_REASON_FULLY_FILLED represents a removal of an order that
+   *  would lead to the subaccount violating isolated subaccount constraints.
+   */
+  REMOVAL_REASON_VIOLATES_ISOLATED_SUBACCOUNT_CONSTRAINTS = 8,
+
+  /**
+   * REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED - REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED represents a removal of an order
+   * that was placed using an expired permissioned key.
+   */
+  REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED = 9,
+  UNRECOGNIZED = -1,
+}
+export const OrderRemoval_RemovalReasonSDKType = OrderRemoval_RemovalReason;
+export function orderRemoval_RemovalReasonFromJSON(object: any): OrderRemoval_RemovalReason {
+  switch (object) {
+    case 0:
+    case "REMOVAL_REASON_UNSPECIFIED":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_UNSPECIFIED;
+
+    case 1:
+    case "REMOVAL_REASON_UNDERCOLLATERALIZED":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_UNDERCOLLATERALIZED;
+
+    case 2:
+    case "REMOVAL_REASON_INVALID_REDUCE_ONLY":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_INVALID_REDUCE_ONLY;
+
+    case 3:
+    case "REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER;
+
+    case 4:
+    case "REMOVAL_REASON_INVALID_SELF_TRADE":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_INVALID_SELF_TRADE;
+
+    case 5:
+    case "REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED;
+
+    case 6:
+    case "REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK;
+
+    case 7:
+    case "REMOVAL_REASON_FULLY_FILLED":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_FULLY_FILLED;
+
+    case 8:
+    case "REMOVAL_REASON_VIOLATES_ISOLATED_SUBACCOUNT_CONSTRAINTS":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_VIOLATES_ISOLATED_SUBACCOUNT_CONSTRAINTS;
+
+    case 9:
+    case "REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED":
+      return OrderRemoval_RemovalReason.REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return OrderRemoval_RemovalReason.UNRECOGNIZED;
+  }
+}
+export function orderRemoval_RemovalReasonToJSON(object: OrderRemoval_RemovalReason): string {
+  switch (object) {
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_UNSPECIFIED:
+      return "REMOVAL_REASON_UNSPECIFIED";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_UNDERCOLLATERALIZED:
+      return "REMOVAL_REASON_UNDERCOLLATERALIZED";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_INVALID_REDUCE_ONLY:
+      return "REMOVAL_REASON_INVALID_REDUCE_ONLY";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER:
+      return "REMOVAL_REASON_POST_ONLY_WOULD_CROSS_MAKER_ORDER";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_INVALID_SELF_TRADE:
+      return "REMOVAL_REASON_INVALID_SELF_TRADE";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED:
+      return "REMOVAL_REASON_CONDITIONAL_FOK_COULD_NOT_BE_FULLY_FILLED";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK:
+      return "REMOVAL_REASON_CONDITIONAL_IOC_WOULD_REST_ON_BOOK";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_FULLY_FILLED:
+      return "REMOVAL_REASON_FULLY_FILLED";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_VIOLATES_ISOLATED_SUBACCOUNT_CONSTRAINTS:
+      return "REMOVAL_REASON_VIOLATES_ISOLATED_SUBACCOUNT_CONSTRAINTS";
+
+    case OrderRemoval_RemovalReason.REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED:
+      return "REMOVAL_REASON_PERMISSIONED_KEY_EXPIRED";
+
+    case OrderRemoval_RemovalReason.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** OrderRemoval is a request type used for forced removal of stateful orders. */
+
+export interface OrderRemoval {
+  orderId?: OrderId;
+  removalReason: OrderRemoval_RemovalReason;
+}
+/** OrderRemoval is a request type used for forced removal of stateful orders. */
+
+export interface OrderRemovalSDKType {
+  order_id?: OrderIdSDKType;
+  removal_reason: OrderRemoval_RemovalReason;
+}
+
+function createBaseOrderRemoval(): OrderRemoval {
+  return {
+    orderId: undefined,
+    removalReason: 0
+  };
+}
+
+export const OrderRemoval = {
+  encode(message: OrderRemoval, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.orderId !== undefined) {
+      OrderId.encode(message.orderId, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.removalReason !== 0) {
+      writer.uint32(16).int32(message.removalReason);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): OrderRemoval {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOrderRemoval();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.orderId = OrderId.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.removalReason = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<OrderRemoval>): OrderRemoval {
+    const message = createBaseOrderRemoval();
+    message.orderId = object.orderId !== undefined && object.orderId !== null ? OrderId.fromPartial(object.orderId) : undefined;
+    message.removalReason = object.removalReason ?? 0;
+    return message;
+  }
+
+};

package/src/codegen/zogux/clob/process_proposer_matches_events.ts

@@ -0,0 +1,176 @@
+import { OrderId, OrderIdSDKType } from "./order";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * ProcessProposerMatchesEvents is used for communicating which events occurred
+ * in the last block that require updating the state of the memclob in the
+ * Commit blocker. It contains information about the following state updates:
+ * - Long term order IDs that were placed in the last block.
+ * - Stateful order IDs that were expired in the last block.
+ * - Order IDs that were filled in the last block.
+ * - Stateful cancellations order IDs that were placed in the last block.
+ * - Stateful order IDs forcefully removed in the last block.
+ * - Conditional order IDs triggered in the last block.
+ * - Conditional order IDs placed, but not triggered in the last block.
+ * - The height of the block in which the events occurred.
+ */
+
+export interface ProcessProposerMatchesEvents {
+  /** @deprecated */
+  placedLongTermOrderIds: OrderId[];
+  expiredStatefulOrderIds: OrderId[];
+  orderIdsFilledInLastBlock: OrderId[];
+  /** @deprecated */
+
+  placedStatefulCancellationOrderIds: OrderId[];
+  removedStatefulOrderIds: OrderId[];
+  conditionalOrderIdsTriggeredInLastBlock: OrderId[];
+  /** @deprecated */
+
+  placedConditionalOrderIds: OrderId[];
+  blockHeight: number;
+}
+/**
+ * ProcessProposerMatchesEvents is used for communicating which events occurred
+ * in the last block that require updating the state of the memclob in the
+ * Commit blocker. It contains information about the following state updates:
+ * - Long term order IDs that were placed in the last block.
+ * - Stateful order IDs that were expired in the last block.
+ * - Order IDs that were filled in the last block.
+ * - Stateful cancellations order IDs that were placed in the last block.
+ * - Stateful order IDs forcefully removed in the last block.
+ * - Conditional order IDs triggered in the last block.
+ * - Conditional order IDs placed, but not triggered in the last block.
+ * - The height of the block in which the events occurred.
+ */
+
+export interface ProcessProposerMatchesEventsSDKType {
+  /** @deprecated */
+  placed_long_term_order_ids: OrderIdSDKType[];
+  expired_stateful_order_ids: OrderIdSDKType[];
+  order_ids_filled_in_last_block: OrderIdSDKType[];
+  /** @deprecated */
+
+  placed_stateful_cancellation_order_ids: OrderIdSDKType[];
+  removed_stateful_order_ids: OrderIdSDKType[];
+  conditional_order_ids_triggered_in_last_block: OrderIdSDKType[];
+  /** @deprecated */
+
+  placed_conditional_order_ids: OrderIdSDKType[];
+  block_height: number;
+}
+
+function createBaseProcessProposerMatchesEvents(): ProcessProposerMatchesEvents {
+  return {
+    placedLongTermOrderIds: [],
+    expiredStatefulOrderIds: [],
+    orderIdsFilledInLastBlock: [],
+    placedStatefulCancellationOrderIds: [],
+    removedStatefulOrderIds: [],
+    conditionalOrderIdsTriggeredInLastBlock: [],
+    placedConditionalOrderIds: [],
+    blockHeight: 0
+  };
+}
+
+export const ProcessProposerMatchesEvents = {
+  encode(message: ProcessProposerMatchesEvents, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.placedLongTermOrderIds) {
+      OrderId.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.expiredStatefulOrderIds) {
+      OrderId.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.orderIdsFilledInLastBlock) {
+      OrderId.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    for (const v of message.placedStatefulCancellationOrderIds) {
+      OrderId.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+
+    for (const v of message.removedStatefulOrderIds) {
+      OrderId.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+
+    for (const v of message.conditionalOrderIdsTriggeredInLastBlock) {
+      OrderId.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+
+    for (const v of message.placedConditionalOrderIds) {
+      OrderId.encode(v!, writer.uint32(58).fork()).ldelim();
+    }
+
+    if (message.blockHeight !== 0) {
+      writer.uint32(64).uint32(message.blockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ProcessProposerMatchesEvents {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProcessProposerMatchesEvents();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.placedLongTermOrderIds.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.expiredStatefulOrderIds.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.orderIdsFilledInLastBlock.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.placedStatefulCancellationOrderIds.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 5:
+          message.removedStatefulOrderIds.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 6:
+          message.conditionalOrderIdsTriggeredInLastBlock.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 7:
+          message.placedConditionalOrderIds.push(OrderId.decode(reader, reader.uint32()));
+          break;
+
+        case 8:
+          message.blockHeight = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ProcessProposerMatchesEvents>): ProcessProposerMatchesEvents {
+    const message = createBaseProcessProposerMatchesEvents();
+    message.placedLongTermOrderIds = object.placedLongTermOrderIds?.map(e => OrderId.fromPartial(e)) || [];
+    message.expiredStatefulOrderIds = object.expiredStatefulOrderIds?.map(e => OrderId.fromPartial(e)) || [];
+    message.orderIdsFilledInLastBlock = object.orderIdsFilledInLastBlock?.map(e => OrderId.fromPartial(e)) || [];
+    message.placedStatefulCancellationOrderIds = object.placedStatefulCancellationOrderIds?.map(e => OrderId.fromPartial(e)) || [];
+    message.removedStatefulOrderIds = object.removedStatefulOrderIds?.map(e => OrderId.fromPartial(e)) || [];
+    message.conditionalOrderIdsTriggeredInLastBlock = object.conditionalOrderIdsTriggeredInLastBlock?.map(e => OrderId.fromPartial(e)) || [];
+    message.placedConditionalOrderIds = object.placedConditionalOrderIds?.map(e => OrderId.fromPartial(e)) || [];
+    message.blockHeight = object.blockHeight ?? 0;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,81 @@
+import { setPaginationParams } from "../../helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryGetClobPairRequest, QueryClobPairResponseSDKType, QueryAllClobPairRequest, QueryClobPairAllResponseSDKType, QueryEquityTierLimitConfigurationRequest, QueryEquityTierLimitConfigurationResponseSDKType, QueryBlockRateLimitConfigurationRequest, QueryBlockRateLimitConfigurationResponseSDKType, QueryLiquidationsConfigurationRequest, QueryLiquidationsConfigurationResponseSDKType, QueryNextClobPairIdRequest, QueryNextClobPairIdResponseSDKType, QueryLeverageRequest, QueryLeverageResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.clobPair = this.clobPair.bind(this);
+    this.clobPairAll = this.clobPairAll.bind(this);
+    this.equityTierLimitConfiguration = this.equityTierLimitConfiguration.bind(this);
+    this.blockRateLimitConfiguration = this.blockRateLimitConfiguration.bind(this);
+    this.liquidationsConfiguration = this.liquidationsConfiguration.bind(this);
+    this.nextClobPairId = this.nextClobPairId.bind(this);
+    this.leverage = this.leverage.bind(this);
+  }
+  /* Queries a ClobPair by id. */
+
+
+  async clobPair(params: QueryGetClobPairRequest): Promise<QueryClobPairResponseSDKType> {
+    const endpoint = `zogux/clob/clob_pair/${params.id}`;
+    return await this.req.get<QueryClobPairResponseSDKType>(endpoint);
+  }
+  /* Queries a list of ClobPair items. */
+
+
+  async clobPairAll(params: QueryAllClobPairRequest = {
+    pagination: undefined
+  }): Promise<QueryClobPairAllResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `zogux/clob/clob_pair`;
+    return await this.req.get<QueryClobPairAllResponseSDKType>(endpoint, options);
+  }
+  /* Queries EquityTierLimitConfiguration. */
+
+
+  async equityTierLimitConfiguration(_params: QueryEquityTierLimitConfigurationRequest = {}): Promise<QueryEquityTierLimitConfigurationResponseSDKType> {
+    const endpoint = `zogux/clob/equity_tier`;
+    return await this.req.get<QueryEquityTierLimitConfigurationResponseSDKType>(endpoint);
+  }
+  /* Queries BlockRateLimitConfiguration. */
+
+
+  async blockRateLimitConfiguration(_params: QueryBlockRateLimitConfigurationRequest = {}): Promise<QueryBlockRateLimitConfigurationResponseSDKType> {
+    const endpoint = `zogux/clob/block_rate`;
+    return await this.req.get<QueryBlockRateLimitConfigurationResponseSDKType>(endpoint);
+  }
+  /* Queries LiquidationsConfiguration. */
+
+
+  async liquidationsConfiguration(_params: QueryLiquidationsConfigurationRequest = {}): Promise<QueryLiquidationsConfigurationResponseSDKType> {
+    const endpoint = `zogux/clob/liquidations_config`;
+    return await this.req.get<QueryLiquidationsConfigurationResponseSDKType>(endpoint);
+  }
+  /* Queries the next clob pair id. */
+
+
+  async nextClobPairId(_params: QueryNextClobPairIdRequest = {}): Promise<QueryNextClobPairIdResponseSDKType> {
+    const endpoint = `zogux/clob/next_clob_pair_id`;
+    return await this.req.get<QueryNextClobPairIdResponseSDKType>(endpoint);
+  }
+  /* Queries leverage for a subaccount. */
+
+
+  async leverage(params: QueryLeverageRequest): Promise<QueryLeverageResponseSDKType> {
+    const endpoint = `zogux/clob/leverage/${params.owner}/${params.number}`;
+    return await this.req.get<QueryLeverageResponseSDKType>(endpoint);
+  }
+
+}

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

@@ -0,0 +1,166 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryGetClobPairRequest, QueryClobPairResponse, QueryAllClobPairRequest, QueryClobPairAllResponse, MevNodeToNodeCalculationRequest, MevNodeToNodeCalculationResponse, QueryEquityTierLimitConfigurationRequest, QueryEquityTierLimitConfigurationResponse, QueryBlockRateLimitConfigurationRequest, QueryBlockRateLimitConfigurationResponse, QueryLiquidationsConfigurationRequest, QueryLiquidationsConfigurationResponse, QueryStatefulOrderRequest, QueryStatefulOrderResponse, QueryNextClobPairIdRequest, QueryNextClobPairIdResponse, QueryLeverageRequest, QueryLeverageResponse, StreamOrderbookUpdatesRequest, StreamOrderbookUpdatesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Queries a ClobPair by id. */
+  clobPair(request: QueryGetClobPairRequest): Promise<QueryClobPairResponse>;
+  /** Queries a list of ClobPair items. */
+
+  clobPairAll(request?: QueryAllClobPairRequest): Promise<QueryClobPairAllResponse>;
+  /** Runs the MEV node <> node calculation with the provided parameters. */
+
+  mevNodeToNodeCalculation(request: MevNodeToNodeCalculationRequest): Promise<MevNodeToNodeCalculationResponse>;
+  /** Queries EquityTierLimitConfiguration. */
+
+  equityTierLimitConfiguration(request?: QueryEquityTierLimitConfigurationRequest): Promise<QueryEquityTierLimitConfigurationResponse>;
+  /** Queries BlockRateLimitConfiguration. */
+
+  blockRateLimitConfiguration(request?: QueryBlockRateLimitConfigurationRequest): Promise<QueryBlockRateLimitConfigurationResponse>;
+  /** Queries LiquidationsConfiguration. */
+
+  liquidationsConfiguration(request?: QueryLiquidationsConfigurationRequest): Promise<QueryLiquidationsConfigurationResponse>;
+  /** Queries the stateful order for a given order id. */
+
+  statefulOrder(request: QueryStatefulOrderRequest): Promise<QueryStatefulOrderResponse>;
+  /** Queries the next clob pair id. */
+
+  nextClobPairId(request?: QueryNextClobPairIdRequest): Promise<QueryNextClobPairIdResponse>;
+  /** Queries leverage for a subaccount. */
+
+  leverage(request: QueryLeverageRequest): Promise<QueryLeverageResponse>;
+  /**
+   * Streams orderbook updates. Updates contain orderbook data
+   * such as order placements, updates, and fills.
+   */
+
+  streamOrderbookUpdates(request: StreamOrderbookUpdatesRequest): Promise<StreamOrderbookUpdatesResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.clobPair = this.clobPair.bind(this);
+    this.clobPairAll = this.clobPairAll.bind(this);
+    this.mevNodeToNodeCalculation = this.mevNodeToNodeCalculation.bind(this);
+    this.equityTierLimitConfiguration = this.equityTierLimitConfiguration.bind(this);
+    this.blockRateLimitConfiguration = this.blockRateLimitConfiguration.bind(this);
+    this.liquidationsConfiguration = this.liquidationsConfiguration.bind(this);
+    this.statefulOrder = this.statefulOrder.bind(this);
+    this.nextClobPairId = this.nextClobPairId.bind(this);
+    this.leverage = this.leverage.bind(this);
+    this.streamOrderbookUpdates = this.streamOrderbookUpdates.bind(this);
+  }
+
+  clobPair(request: QueryGetClobPairRequest): Promise<QueryClobPairResponse> {
+    const data = QueryGetClobPairRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "ClobPair", data);
+    return promise.then(data => QueryClobPairResponse.decode(new _m0.Reader(data)));
+  }
+
+  clobPairAll(request: QueryAllClobPairRequest = {
+    pagination: undefined
+  }): Promise<QueryClobPairAllResponse> {
+    const data = QueryAllClobPairRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "ClobPairAll", data);
+    return promise.then(data => QueryClobPairAllResponse.decode(new _m0.Reader(data)));
+  }
+
+  mevNodeToNodeCalculation(request: MevNodeToNodeCalculationRequest): Promise<MevNodeToNodeCalculationResponse> {
+    const data = MevNodeToNodeCalculationRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "MevNodeToNodeCalculation", data);
+    return promise.then(data => MevNodeToNodeCalculationResponse.decode(new _m0.Reader(data)));
+  }
+
+  equityTierLimitConfiguration(request: QueryEquityTierLimitConfigurationRequest = {}): Promise<QueryEquityTierLimitConfigurationResponse> {
+    const data = QueryEquityTierLimitConfigurationRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "EquityTierLimitConfiguration", data);
+    return promise.then(data => QueryEquityTierLimitConfigurationResponse.decode(new _m0.Reader(data)));
+  }
+
+  blockRateLimitConfiguration(request: QueryBlockRateLimitConfigurationRequest = {}): Promise<QueryBlockRateLimitConfigurationResponse> {
+    const data = QueryBlockRateLimitConfigurationRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "BlockRateLimitConfiguration", data);
+    return promise.then(data => QueryBlockRateLimitConfigurationResponse.decode(new _m0.Reader(data)));
+  }
+
+  liquidationsConfiguration(request: QueryLiquidationsConfigurationRequest = {}): Promise<QueryLiquidationsConfigurationResponse> {
+    const data = QueryLiquidationsConfigurationRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "LiquidationsConfiguration", data);
+    return promise.then(data => QueryLiquidationsConfigurationResponse.decode(new _m0.Reader(data)));
+  }
+
+  statefulOrder(request: QueryStatefulOrderRequest): Promise<QueryStatefulOrderResponse> {
+    const data = QueryStatefulOrderRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "StatefulOrder", data);
+    return promise.then(data => QueryStatefulOrderResponse.decode(new _m0.Reader(data)));
+  }
+
+  nextClobPairId(request: QueryNextClobPairIdRequest = {}): Promise<QueryNextClobPairIdResponse> {
+    const data = QueryNextClobPairIdRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "NextClobPairId", data);
+    return promise.then(data => QueryNextClobPairIdResponse.decode(new _m0.Reader(data)));
+  }
+
+  leverage(request: QueryLeverageRequest): Promise<QueryLeverageResponse> {
+    const data = QueryLeverageRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "Leverage", data);
+    return promise.then(data => QueryLeverageResponse.decode(new _m0.Reader(data)));
+  }
+
+  streamOrderbookUpdates(request: StreamOrderbookUpdatesRequest): Promise<StreamOrderbookUpdatesResponse> {
+    const data = StreamOrderbookUpdatesRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Query", "StreamOrderbookUpdates", data);
+    return promise.then(data => StreamOrderbookUpdatesResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    clobPair(request: QueryGetClobPairRequest): Promise<QueryClobPairResponse> {
+      return queryService.clobPair(request);
+    },
+
+    clobPairAll(request?: QueryAllClobPairRequest): Promise<QueryClobPairAllResponse> {
+      return queryService.clobPairAll(request);
+    },
+
+    mevNodeToNodeCalculation(request: MevNodeToNodeCalculationRequest): Promise<MevNodeToNodeCalculationResponse> {
+      return queryService.mevNodeToNodeCalculation(request);
+    },
+
+    equityTierLimitConfiguration(request?: QueryEquityTierLimitConfigurationRequest): Promise<QueryEquityTierLimitConfigurationResponse> {
+      return queryService.equityTierLimitConfiguration(request);
+    },
+
+    blockRateLimitConfiguration(request?: QueryBlockRateLimitConfigurationRequest): Promise<QueryBlockRateLimitConfigurationResponse> {
+      return queryService.blockRateLimitConfiguration(request);
+    },
+
+    liquidationsConfiguration(request?: QueryLiquidationsConfigurationRequest): Promise<QueryLiquidationsConfigurationResponse> {
+      return queryService.liquidationsConfiguration(request);
+    },
+
+    statefulOrder(request: QueryStatefulOrderRequest): Promise<QueryStatefulOrderResponse> {
+      return queryService.statefulOrder(request);
+    },
+
+    nextClobPairId(request?: QueryNextClobPairIdRequest): Promise<QueryNextClobPairIdResponse> {
+      return queryService.nextClobPairId(request);
+    },
+
+    leverage(request: QueryLeverageRequest): Promise<QueryLeverageResponse> {
+      return queryService.leverage(request);
+    },
+
+    streamOrderbookUpdates(request: StreamOrderbookUpdatesRequest): Promise<StreamOrderbookUpdatesResponse> {
+      return queryService.streamOrderbookUpdates(request);
+    }
+
+  };
+};