@zoguxprotocol/proto 0.1.0

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

@@ -0,0 +1,96 @@
+import { StreamOrderbookFill, StreamOrderbookFillSDKType, StreamOrderbookUpdate, StreamOrderbookUpdateSDKType } from "./query";
+import { StreamSubaccountUpdate, StreamSubaccountUpdateSDKType } from "../subaccounts/streaming";
+import { StreamPriceUpdate, StreamPriceUpdateSDKType } from "../prices/streaming";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** StagedFinalizeBlockEvent is an event staged during `FinalizeBlock`. */
+
+export interface StagedFinalizeBlockEvent {
+  orderFill?: StreamOrderbookFill;
+  subaccountUpdate?: StreamSubaccountUpdate;
+  orderbookUpdate?: StreamOrderbookUpdate;
+  priceUpdate?: StreamPriceUpdate;
+}
+/** StagedFinalizeBlockEvent is an event staged during `FinalizeBlock`. */
+
+export interface StagedFinalizeBlockEventSDKType {
+  order_fill?: StreamOrderbookFillSDKType;
+  subaccount_update?: StreamSubaccountUpdateSDKType;
+  orderbook_update?: StreamOrderbookUpdateSDKType;
+  price_update?: StreamPriceUpdateSDKType;
+}
+
+function createBaseStagedFinalizeBlockEvent(): StagedFinalizeBlockEvent {
+  return {
+    orderFill: undefined,
+    subaccountUpdate: undefined,
+    orderbookUpdate: undefined,
+    priceUpdate: undefined
+  };
+}
+
+export const StagedFinalizeBlockEvent = {
+  encode(message: StagedFinalizeBlockEvent, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.orderFill !== undefined) {
+      StreamOrderbookFill.encode(message.orderFill, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.subaccountUpdate !== undefined) {
+      StreamSubaccountUpdate.encode(message.subaccountUpdate, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.orderbookUpdate !== undefined) {
+      StreamOrderbookUpdate.encode(message.orderbookUpdate, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.priceUpdate !== undefined) {
+      StreamPriceUpdate.encode(message.priceUpdate, writer.uint32(34).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StagedFinalizeBlockEvent {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStagedFinalizeBlockEvent();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.orderFill = StreamOrderbookFill.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.subaccountUpdate = StreamSubaccountUpdate.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.orderbookUpdate = StreamOrderbookUpdate.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.priceUpdate = StreamPriceUpdate.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<StagedFinalizeBlockEvent>): StagedFinalizeBlockEvent {
+    const message = createBaseStagedFinalizeBlockEvent();
+    message.orderFill = object.orderFill !== undefined && object.orderFill !== null ? StreamOrderbookFill.fromPartial(object.orderFill) : undefined;
+    message.subaccountUpdate = object.subaccountUpdate !== undefined && object.subaccountUpdate !== null ? StreamSubaccountUpdate.fromPartial(object.subaccountUpdate) : undefined;
+    message.orderbookUpdate = object.orderbookUpdate !== undefined && object.orderbookUpdate !== null ? StreamOrderbookUpdate.fromPartial(object.orderbookUpdate) : undefined;
+    message.priceUpdate = object.priceUpdate !== undefined && object.priceUpdate !== null ? StreamPriceUpdate.fromPartial(object.priceUpdate) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/zogux/clob/tx.rpc.msg.ts

@@ -0,0 +1,131 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgProposedOperations, MsgProposedOperationsResponse, MsgPlaceOrder, MsgPlaceOrderResponse, MsgCancelOrder, MsgCancelOrderResponse, MsgBatchCancel, MsgBatchCancelResponse, MsgCreateClobPair, MsgCreateClobPairResponse, MsgUpdateClobPair, MsgUpdateClobPairResponse, MsgUpdateEquityTierLimitConfiguration, MsgUpdateEquityTierLimitConfigurationResponse, MsgUpdateBlockRateLimitConfiguration, MsgUpdateBlockRateLimitConfigurationResponse, MsgUpdateLiquidationsConfig, MsgUpdateLiquidationsConfigResponse, MsgUpdateLeverage, MsgUpdateLeverageResponse } from "./tx";
+/** Msg defines the Msg service. */
+
+export interface Msg {
+  /**
+   * ProposedOperations is a temporary message used by block proposers
+   * for matching orders as part of the ABCI++ workaround.
+   */
+  proposedOperations(request: MsgProposedOperations): Promise<MsgProposedOperationsResponse>;
+  /** PlaceOrder allows accounts to place orders on the orderbook. */
+
+  placeOrder(request: MsgPlaceOrder): Promise<MsgPlaceOrderResponse>;
+  /** CancelOrder allows accounts to cancel existing orders on the orderbook. */
+
+  cancelOrder(request: MsgCancelOrder): Promise<MsgCancelOrderResponse>;
+  /** BatchCancel allows accounts to cancel a batch of orders on the orderbook. */
+
+  batchCancel(request: MsgBatchCancel): Promise<MsgBatchCancelResponse>;
+  /** CreateClobPair creates a new clob pair. */
+
+  createClobPair(request: MsgCreateClobPair): Promise<MsgCreateClobPairResponse>;
+  /**
+   * UpdateClobPair sets the status of a clob pair. Should return an error
+   * if the authority is not in the clob keeper's set of authorities,
+   * if the ClobPair id is not found in state, or if the update includes
+   * an unsupported status transition.
+   */
+
+  updateClobPair(request: MsgUpdateClobPair): Promise<MsgUpdateClobPairResponse>;
+  /**
+   * UpdateEquityTierLimitConfiguration updates the equity tier limit
+   * configuration in state.
+   */
+
+  updateEquityTierLimitConfiguration(request: MsgUpdateEquityTierLimitConfiguration): Promise<MsgUpdateEquityTierLimitConfigurationResponse>;
+  /**
+   * UpdateBlockRateLimitConfiguration updates the block rate limit
+   * configuration in state.
+   */
+
+  updateBlockRateLimitConfiguration(request: MsgUpdateBlockRateLimitConfiguration): Promise<MsgUpdateBlockRateLimitConfigurationResponse>;
+  /** UpdateLiquidationsConfig updates the liquidations configuration in state. */
+
+  updateLiquidationsConfig(request: MsgUpdateLiquidationsConfig): Promise<MsgUpdateLiquidationsConfigResponse>;
+  /**
+   * UpdateLeverage allows accounts to update their desired leverage for
+   * clob pairs.
+   */
+
+  updateLeverage(request: MsgUpdateLeverage): Promise<MsgUpdateLeverageResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.proposedOperations = this.proposedOperations.bind(this);
+    this.placeOrder = this.placeOrder.bind(this);
+    this.cancelOrder = this.cancelOrder.bind(this);
+    this.batchCancel = this.batchCancel.bind(this);
+    this.createClobPair = this.createClobPair.bind(this);
+    this.updateClobPair = this.updateClobPair.bind(this);
+    this.updateEquityTierLimitConfiguration = this.updateEquityTierLimitConfiguration.bind(this);
+    this.updateBlockRateLimitConfiguration = this.updateBlockRateLimitConfiguration.bind(this);
+    this.updateLiquidationsConfig = this.updateLiquidationsConfig.bind(this);
+    this.updateLeverage = this.updateLeverage.bind(this);
+  }
+
+  proposedOperations(request: MsgProposedOperations): Promise<MsgProposedOperationsResponse> {
+    const data = MsgProposedOperations.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "ProposedOperations", data);
+    return promise.then(data => MsgProposedOperationsResponse.decode(new _m0.Reader(data)));
+  }
+
+  placeOrder(request: MsgPlaceOrder): Promise<MsgPlaceOrderResponse> {
+    const data = MsgPlaceOrder.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "PlaceOrder", data);
+    return promise.then(data => MsgPlaceOrderResponse.decode(new _m0.Reader(data)));
+  }
+
+  cancelOrder(request: MsgCancelOrder): Promise<MsgCancelOrderResponse> {
+    const data = MsgCancelOrder.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "CancelOrder", data);
+    return promise.then(data => MsgCancelOrderResponse.decode(new _m0.Reader(data)));
+  }
+
+  batchCancel(request: MsgBatchCancel): Promise<MsgBatchCancelResponse> {
+    const data = MsgBatchCancel.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "BatchCancel", data);
+    return promise.then(data => MsgBatchCancelResponse.decode(new _m0.Reader(data)));
+  }
+
+  createClobPair(request: MsgCreateClobPair): Promise<MsgCreateClobPairResponse> {
+    const data = MsgCreateClobPair.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "CreateClobPair", data);
+    return promise.then(data => MsgCreateClobPairResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateClobPair(request: MsgUpdateClobPair): Promise<MsgUpdateClobPairResponse> {
+    const data = MsgUpdateClobPair.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "UpdateClobPair", data);
+    return promise.then(data => MsgUpdateClobPairResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateEquityTierLimitConfiguration(request: MsgUpdateEquityTierLimitConfiguration): Promise<MsgUpdateEquityTierLimitConfigurationResponse> {
+    const data = MsgUpdateEquityTierLimitConfiguration.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "UpdateEquityTierLimitConfiguration", data);
+    return promise.then(data => MsgUpdateEquityTierLimitConfigurationResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateBlockRateLimitConfiguration(request: MsgUpdateBlockRateLimitConfiguration): Promise<MsgUpdateBlockRateLimitConfigurationResponse> {
+    const data = MsgUpdateBlockRateLimitConfiguration.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "UpdateBlockRateLimitConfiguration", data);
+    return promise.then(data => MsgUpdateBlockRateLimitConfigurationResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateLiquidationsConfig(request: MsgUpdateLiquidationsConfig): Promise<MsgUpdateLiquidationsConfigResponse> {
+    const data = MsgUpdateLiquidationsConfig.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "UpdateLiquidationsConfig", data);
+    return promise.then(data => MsgUpdateLiquidationsConfigResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateLeverage(request: MsgUpdateLeverage): Promise<MsgUpdateLeverageResponse> {
+    const data = MsgUpdateLeverage.encode(request).finish();
+    const promise = this.rpc.request("zogux.clob.Msg", "UpdateLeverage", data);
+    return promise.then(data => MsgUpdateLeverageResponse.decode(new _m0.Reader(data)));
+  }
+
+}