@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/daemons/bridge/bridge.ts

@@ -0,0 +1,104 @@
+import { BridgeEvent, BridgeEventSDKType } from "../../bridge/bridge_event";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * AddBridgeEventsRequest is a request message that contains a list of new
+ * bridge events. The events should be contiguous and sorted by (unique) id.
+ */
+
+export interface AddBridgeEventsRequest {
+  bridgeEvents: BridgeEvent[];
+}
+/**
+ * AddBridgeEventsRequest is a request message that contains a list of new
+ * bridge events. The events should be contiguous and sorted by (unique) id.
+ */
+
+export interface AddBridgeEventsRequestSDKType {
+  bridge_events: BridgeEventSDKType[];
+}
+/** AddBridgeEventsResponse is a response message for BridgeEventRequest. */
+
+export interface AddBridgeEventsResponse {}
+/** AddBridgeEventsResponse is a response message for BridgeEventRequest. */
+
+export interface AddBridgeEventsResponseSDKType {}
+
+function createBaseAddBridgeEventsRequest(): AddBridgeEventsRequest {
+  return {
+    bridgeEvents: []
+  };
+}
+
+export const AddBridgeEventsRequest = {
+  encode(message: AddBridgeEventsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.bridgeEvents) {
+      BridgeEvent.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AddBridgeEventsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAddBridgeEventsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.bridgeEvents.push(BridgeEvent.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<AddBridgeEventsRequest>): AddBridgeEventsRequest {
+    const message = createBaseAddBridgeEventsRequest();
+    message.bridgeEvents = object.bridgeEvents?.map(e => BridgeEvent.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseAddBridgeEventsResponse(): AddBridgeEventsResponse {
+  return {};
+}
+
+export const AddBridgeEventsResponse = {
+  encode(_: AddBridgeEventsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AddBridgeEventsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAddBridgeEventsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<AddBridgeEventsResponse>): AddBridgeEventsResponse {
+    const message = createBaseAddBridgeEventsResponse();
+    return message;
+  }
+
+};

package/src/codegen/zogux/daemons/liquidation/liquidation.ts

@@ -0,0 +1,156 @@
+import { SubaccountId, SubaccountIdSDKType } from "../../subaccounts/subaccount";
+import { SubaccountOpenPositionInfo, SubaccountOpenPositionInfoSDKType } from "../../clob/liquidations";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * LiquidateSubaccountsRequest is a request message that contains a list of
+ * subaccount ids that potentially need to be liquidated. The list of subaccount
+ * ids should not contain duplicates. The application should re-verify these
+ * subaccount ids against current state before liquidating their positions.
+ */
+
+export interface LiquidateSubaccountsRequest {
+  /** The block height at which the liquidation daemon is processing. */
+  blockHeight: number;
+  /** The list of liquidatable subaccount ids. */
+
+  liquidatableSubaccountIds: SubaccountId[];
+  /** The list of subaccount ids with negative total net collateral. */
+
+  negativeTncSubaccountIds: SubaccountId[];
+  subaccountOpenPositionInfo: SubaccountOpenPositionInfo[];
+}
+/**
+ * LiquidateSubaccountsRequest is a request message that contains a list of
+ * subaccount ids that potentially need to be liquidated. The list of subaccount
+ * ids should not contain duplicates. The application should re-verify these
+ * subaccount ids against current state before liquidating their positions.
+ */
+
+export interface LiquidateSubaccountsRequestSDKType {
+  block_height: number;
+  liquidatable_subaccount_ids: SubaccountIdSDKType[];
+  negative_tnc_subaccount_ids: SubaccountIdSDKType[];
+  subaccount_open_position_info: SubaccountOpenPositionInfoSDKType[];
+}
+/**
+ * LiquidateSubaccountsResponse is a response message for
+ * LiquidateSubaccountsRequest.
+ */
+
+export interface LiquidateSubaccountsResponse {}
+/**
+ * LiquidateSubaccountsResponse is a response message for
+ * LiquidateSubaccountsRequest.
+ */
+
+export interface LiquidateSubaccountsResponseSDKType {}
+
+function createBaseLiquidateSubaccountsRequest(): LiquidateSubaccountsRequest {
+  return {
+    blockHeight: 0,
+    liquidatableSubaccountIds: [],
+    negativeTncSubaccountIds: [],
+    subaccountOpenPositionInfo: []
+  };
+}
+
+export const LiquidateSubaccountsRequest = {
+  encode(message: LiquidateSubaccountsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.blockHeight !== 0) {
+      writer.uint32(8).uint32(message.blockHeight);
+    }
+
+    for (const v of message.liquidatableSubaccountIds) {
+      SubaccountId.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.negativeTncSubaccountIds) {
+      SubaccountId.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    for (const v of message.subaccountOpenPositionInfo) {
+      SubaccountOpenPositionInfo.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LiquidateSubaccountsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLiquidateSubaccountsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.blockHeight = reader.uint32();
+          break;
+
+        case 2:
+          message.liquidatableSubaccountIds.push(SubaccountId.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.negativeTncSubaccountIds.push(SubaccountId.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.subaccountOpenPositionInfo.push(SubaccountOpenPositionInfo.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LiquidateSubaccountsRequest>): LiquidateSubaccountsRequest {
+    const message = createBaseLiquidateSubaccountsRequest();
+    message.blockHeight = object.blockHeight ?? 0;
+    message.liquidatableSubaccountIds = object.liquidatableSubaccountIds?.map(e => SubaccountId.fromPartial(e)) || [];
+    message.negativeTncSubaccountIds = object.negativeTncSubaccountIds?.map(e => SubaccountId.fromPartial(e)) || [];
+    message.subaccountOpenPositionInfo = object.subaccountOpenPositionInfo?.map(e => SubaccountOpenPositionInfo.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseLiquidateSubaccountsResponse(): LiquidateSubaccountsResponse {
+  return {};
+}
+
+export const LiquidateSubaccountsResponse = {
+  encode(_: LiquidateSubaccountsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LiquidateSubaccountsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLiquidateSubaccountsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<LiquidateSubaccountsResponse>): LiquidateSubaccountsResponse {
+    const message = createBaseLiquidateSubaccountsResponse();
+    return message;
+  }
+
+};

package/src/codegen/zogux/daemons/pricefeed/price_feed.ts

@@ -0,0 +1,244 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long, toTimestamp, fromTimestamp } from "../../../helpers";
+/** UpdateMarketPriceRequest is a request message updating market prices. */
+
+export interface UpdateMarketPricesRequest {
+  marketPriceUpdates: MarketPriceUpdate[];
+}
+/** UpdateMarketPriceRequest is a request message updating market prices. */
+
+export interface UpdateMarketPricesRequestSDKType {
+  market_price_updates: MarketPriceUpdateSDKType[];
+}
+/** UpdateMarketPricesResponse is a response message for updating market prices. */
+
+export interface UpdateMarketPricesResponse {}
+/** UpdateMarketPricesResponse is a response message for updating market prices. */
+
+export interface UpdateMarketPricesResponseSDKType {}
+/** ExchangePrice represents a specific exchange's market price */
+
+export interface ExchangePrice {
+  exchangeId: string;
+  price: Long;
+  lastUpdateTime?: Date;
+}
+/** ExchangePrice represents a specific exchange's market price */
+
+export interface ExchangePriceSDKType {
+  exchange_id: string;
+  price: Long;
+  last_update_time?: Date;
+}
+/** MarketPriceUpdate represents an update to a single market */
+
+export interface MarketPriceUpdate {
+  marketId: number;
+  exchangePrices: ExchangePrice[];
+}
+/** MarketPriceUpdate represents an update to a single market */
+
+export interface MarketPriceUpdateSDKType {
+  market_id: number;
+  exchange_prices: ExchangePriceSDKType[];
+}
+
+function createBaseUpdateMarketPricesRequest(): UpdateMarketPricesRequest {
+  return {
+    marketPriceUpdates: []
+  };
+}
+
+export const UpdateMarketPricesRequest = {
+  encode(message: UpdateMarketPricesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.marketPriceUpdates) {
+      MarketPriceUpdate.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): UpdateMarketPricesRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMarketPricesRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.marketPriceUpdates.push(MarketPriceUpdate.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<UpdateMarketPricesRequest>): UpdateMarketPricesRequest {
+    const message = createBaseUpdateMarketPricesRequest();
+    message.marketPriceUpdates = object.marketPriceUpdates?.map(e => MarketPriceUpdate.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseUpdateMarketPricesResponse(): UpdateMarketPricesResponse {
+  return {};
+}
+
+export const UpdateMarketPricesResponse = {
+  encode(_: UpdateMarketPricesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): UpdateMarketPricesResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMarketPricesResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<UpdateMarketPricesResponse>): UpdateMarketPricesResponse {
+    const message = createBaseUpdateMarketPricesResponse();
+    return message;
+  }
+
+};
+
+function createBaseExchangePrice(): ExchangePrice {
+  return {
+    exchangeId: "",
+    price: Long.UZERO,
+    lastUpdateTime: undefined
+  };
+}
+
+export const ExchangePrice = {
+  encode(message: ExchangePrice, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.exchangeId !== "") {
+      writer.uint32(10).string(message.exchangeId);
+    }
+
+    if (!message.price.isZero()) {
+      writer.uint32(16).uint64(message.price);
+    }
+
+    if (message.lastUpdateTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.lastUpdateTime), writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ExchangePrice {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExchangePrice();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.exchangeId = reader.string();
+          break;
+
+        case 2:
+          message.price = (reader.uint64() as Long);
+          break;
+
+        case 3:
+          message.lastUpdateTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ExchangePrice>): ExchangePrice {
+    const message = createBaseExchangePrice();
+    message.exchangeId = object.exchangeId ?? "";
+    message.price = object.price !== undefined && object.price !== null ? Long.fromValue(object.price) : Long.UZERO;
+    message.lastUpdateTime = object.lastUpdateTime ?? undefined;
+    return message;
+  }
+
+};
+
+function createBaseMarketPriceUpdate(): MarketPriceUpdate {
+  return {
+    marketId: 0,
+    exchangePrices: []
+  };
+}
+
+export const MarketPriceUpdate = {
+  encode(message: MarketPriceUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.marketId !== 0) {
+      writer.uint32(8).uint32(message.marketId);
+    }
+
+    for (const v of message.exchangePrices) {
+      ExchangePrice.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MarketPriceUpdate {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMarketPriceUpdate();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.marketId = reader.uint32();
+          break;
+
+        case 2:
+          message.exchangePrices.push(ExchangePrice.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MarketPriceUpdate>): MarketPriceUpdate {
+    const message = createBaseMarketPriceUpdate();
+    message.marketId = object.marketId ?? 0;
+    message.exchangePrices = object.exchangePrices?.map(e => ExchangePrice.fromPartial(e)) || [];
+    return message;
+  }
+
+};

package/src/codegen/zogux/delaymsg/block_message_ids.ts

@@ -0,0 +1,79 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * BlockMessageIds stores the id of each message that should be processed at a
+ * given block height.
+ */
+
+export interface BlockMessageIds {
+  /**
+   * ids stores a list of DelayedMessage ids that should be processed at a given
+   * block height.
+   */
+  ids: number[];
+}
+/**
+ * BlockMessageIds stores the id of each message that should be processed at a
+ * given block height.
+ */
+
+export interface BlockMessageIdsSDKType {
+  ids: number[];
+}
+
+function createBaseBlockMessageIds(): BlockMessageIds {
+  return {
+    ids: []
+  };
+}
+
+export const BlockMessageIds = {
+  encode(message: BlockMessageIds, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+
+    for (const v of message.ids) {
+      writer.uint32(v);
+    }
+
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BlockMessageIds {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockMessageIds();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+
+            while (reader.pos < end2) {
+              message.ids.push(reader.uint32());
+            }
+          } else {
+            message.ids.push(reader.uint32());
+          }
+
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BlockMessageIds>): BlockMessageIds {
+    const message = createBaseBlockMessageIds();
+    message.ids = object.ids?.map(e => e) || [];
+    return message;
+  }
+
+};

package/src/codegen/zogux/delaymsg/delayed_message.ts

@@ -0,0 +1,87 @@
+import { Any, AnySDKType } from "../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** DelayedMessage is a message that is delayed until a certain block height. */
+
+export interface DelayedMessage {
+  /** The ID of the delayed message. */
+  id: number;
+  /** The message to be executed. */
+
+  msg?: Any;
+  /** The block height at which the message should be executed. */
+
+  blockHeight: number;
+}
+/** DelayedMessage is a message that is delayed until a certain block height. */
+
+export interface DelayedMessageSDKType {
+  id: number;
+  msg?: AnySDKType;
+  block_height: number;
+}
+
+function createBaseDelayedMessage(): DelayedMessage {
+  return {
+    id: 0,
+    msg: undefined,
+    blockHeight: 0
+  };
+}
+
+export const DelayedMessage = {
+  encode(message: DelayedMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.msg !== undefined) {
+      Any.encode(message.msg, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.blockHeight !== 0) {
+      writer.uint32(24).uint32(message.blockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DelayedMessage {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDelayedMessage();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.msg = Any.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.blockHeight = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<DelayedMessage>): DelayedMessage {
+    const message = createBaseDelayedMessage();
+    message.id = object.id ?? 0;
+    message.msg = object.msg !== undefined && object.msg !== null ? Any.fromPartial(object.msg) : undefined;
+    message.blockHeight = object.blockHeight ?? 0;
+    return message;
+  }
+
+};