@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/perpetuals/perpetual.ts

@@ -0,0 +1,660 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+export enum PerpetualMarketType {
+  /** PERPETUAL_MARKET_TYPE_UNSPECIFIED - Unspecified market type. */
+  PERPETUAL_MARKET_TYPE_UNSPECIFIED = 0,
+
+  /** PERPETUAL_MARKET_TYPE_CROSS - Market type for cross margin perpetual markets. */
+  PERPETUAL_MARKET_TYPE_CROSS = 1,
+
+  /** PERPETUAL_MARKET_TYPE_ISOLATED - Market type for isolated margin perpetual markets. */
+  PERPETUAL_MARKET_TYPE_ISOLATED = 2,
+  UNRECOGNIZED = -1,
+}
+export const PerpetualMarketTypeSDKType = PerpetualMarketType;
+export function perpetualMarketTypeFromJSON(object: any): PerpetualMarketType {
+  switch (object) {
+    case 0:
+    case "PERPETUAL_MARKET_TYPE_UNSPECIFIED":
+      return PerpetualMarketType.PERPETUAL_MARKET_TYPE_UNSPECIFIED;
+
+    case 1:
+    case "PERPETUAL_MARKET_TYPE_CROSS":
+      return PerpetualMarketType.PERPETUAL_MARKET_TYPE_CROSS;
+
+    case 2:
+    case "PERPETUAL_MARKET_TYPE_ISOLATED":
+      return PerpetualMarketType.PERPETUAL_MARKET_TYPE_ISOLATED;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return PerpetualMarketType.UNRECOGNIZED;
+  }
+}
+export function perpetualMarketTypeToJSON(object: PerpetualMarketType): string {
+  switch (object) {
+    case PerpetualMarketType.PERPETUAL_MARKET_TYPE_UNSPECIFIED:
+      return "PERPETUAL_MARKET_TYPE_UNSPECIFIED";
+
+    case PerpetualMarketType.PERPETUAL_MARKET_TYPE_CROSS:
+      return "PERPETUAL_MARKET_TYPE_CROSS";
+
+    case PerpetualMarketType.PERPETUAL_MARKET_TYPE_ISOLATED:
+      return "PERPETUAL_MARKET_TYPE_ISOLATED";
+
+    case PerpetualMarketType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** Perpetual represents a perpetual on the Zogux exchange. */
+
+export interface Perpetual {
+  /** PerpetualParams is the parameters of the perpetual. */
+  params?: PerpetualParams;
+  /**
+   * The current index determined by the cumulative all-time
+   * history of the funding mechanism. Starts at zero.
+   */
+
+  fundingIndex: Uint8Array;
+  /** Total size of open long contracts, measured in base_quantums. */
+
+  openInterest: Uint8Array;
+}
+/** Perpetual represents a perpetual on the Zogux exchange. */
+
+export interface PerpetualSDKType {
+  params?: PerpetualParamsSDKType;
+  funding_index: Uint8Array;
+  open_interest: Uint8Array;
+}
+/**
+ * PerpetualParams represents the parameters of a perpetual on the Zogux
+ * exchange.
+ */
+
+export interface PerpetualParams {
+  /** Unique, sequentially-generated. */
+  id: number;
+  /** The name of the `Perpetual` (e.g. `BTC-USD`). */
+
+  ticker: string;
+  /**
+   * The market associated with this `Perpetual`. It
+   * acts as the oracle price for the purposes of calculating
+   * collateral, margin requirements, and funding rates.
+   */
+
+  marketId: number;
+  /**
+   * The exponent for converting an atomic amount (`size = 1`)
+   * to a full coin. For example, if `AtomicResolution = -8`
+   * then a `PerpetualPosition` with `size = 1e8` is equivalent to
+   * a position size of one full coin.
+   */
+
+  atomicResolution: number;
+  /**
+   * The default (8hr) funding payment if there is no price premium. In
+   * parts-per-million.
+   */
+
+  defaultFundingPpm: number;
+  /** The liquidity_tier that this perpetual is associated with. */
+
+  liquidityTier: number;
+  /** The market type specifying if this perpetual is cross or isolated */
+
+  marketType: PerpetualMarketType;
+}
+/**
+ * PerpetualParams represents the parameters of a perpetual on the Zogux
+ * exchange.
+ */
+
+export interface PerpetualParamsSDKType {
+  id: number;
+  ticker: string;
+  market_id: number;
+  atomic_resolution: number;
+  default_funding_ppm: number;
+  liquidity_tier: number;
+  market_type: PerpetualMarketType;
+}
+/** MarketPremiums stores a list of premiums for a single perpetual market. */
+
+export interface MarketPremiums {
+  /** perpetual_id is the Id of the perpetual market. */
+  perpetualId: number;
+  /**
+   * premiums is a list of premium values for a perpetual market. Since most
+   * premiums are zeros under "stable" market conditions, only non-zero values
+   * are stored in this list.
+   */
+
+  premiums: number[];
+}
+/** MarketPremiums stores a list of premiums for a single perpetual market. */
+
+export interface MarketPremiumsSDKType {
+  perpetual_id: number;
+  premiums: number[];
+}
+/**
+ * PremiumStore is a struct to store a perpetual premiums for all
+ * perpetual markets. It stores a list of `MarketPremiums`, each of which
+ * corresponds to a perpetual market and stores a list of non-zero premium
+ * values for that market.
+ * This struct can either be used to store `PremiumVotes` or
+ * `PremiumSamples`.
+ */
+
+export interface PremiumStore {
+  /**
+   * all_market_premiums a list of `MarketPremiums`, each corresponding to
+   * a perpetual market.
+   */
+  allMarketPremiums: MarketPremiums[];
+  /**
+   * number of rounds where premium values were added. This value indicates
+   * the total number of premiums (zeros and non-zeros) for each
+   * `MarketPremiums` struct. Note that in the edge case a perpetual market was
+   * added in the middle of a epoch, we don't keep a seperate count for that
+   * market. This means we treat this market as having zero premiums before it
+   * was added.
+   */
+
+  numPremiums: number;
+}
+/**
+ * PremiumStore is a struct to store a perpetual premiums for all
+ * perpetual markets. It stores a list of `MarketPremiums`, each of which
+ * corresponds to a perpetual market and stores a list of non-zero premium
+ * values for that market.
+ * This struct can either be used to store `PremiumVotes` or
+ * `PremiumSamples`.
+ */
+
+export interface PremiumStoreSDKType {
+  all_market_premiums: MarketPremiumsSDKType[];
+  num_premiums: number;
+}
+/** LiquidityTier stores margin information. */
+
+export interface LiquidityTier {
+  /** Unique id. */
+  id: number;
+  /** The name of the tier purely for mnemonic purposes, e.g. "Gold". */
+
+  name: string;
+  /**
+   * The margin fraction needed to open a position.
+   * In parts-per-million.
+   */
+
+  initialMarginPpm: number;
+  /**
+   * The fraction of the initial-margin that the maintenance-margin is,
+   * e.g. 50%. In parts-per-million.
+   */
+
+  maintenanceFractionPpm: number;
+  /**
+   * The maximum position size at which the margin requirements are
+   * not increased over the default values. Above this position size,
+   * the margin requirements increase at a rate of sqrt(size).
+   * 
+   * Deprecated since v3.x.
+   */
+
+  /** @deprecated */
+
+  basePositionNotional: Long;
+  /**
+   * The impact notional amount (in quote quantums) is used to determine impact
+   * bid/ask prices and its recommended value is 500 USDC / initial margin
+   * fraction.
+   * - Impact bid price = average execution price for a market sell of the
+   * impact notional value.
+   * - Impact ask price = average execution price for a market buy of the
+   * impact notional value.
+   */
+
+  impactNotional: Long;
+  /**
+   * Lower cap for Open Interest Margin Fracton (OIMF), in quote quantums.
+   * IMF is not affected when OI <= open_interest_lower_cap.
+   */
+
+  openInterestLowerCap: Long;
+  /**
+   * Upper cap for Open Interest Margin Fracton (OIMF), in quote quantums.
+   * IMF scales linearly to 100% as OI approaches open_interest_upper_cap.
+   * If zero, then the IMF does not scale with OI.
+   */
+
+  openInterestUpperCap: Long;
+}
+/** LiquidityTier stores margin information. */
+
+export interface LiquidityTierSDKType {
+  id: number;
+  name: string;
+  initial_margin_ppm: number;
+  maintenance_fraction_ppm: number;
+  /** @deprecated */
+
+  base_position_notional: Long;
+  impact_notional: Long;
+  open_interest_lower_cap: Long;
+  open_interest_upper_cap: Long;
+}
+
+function createBasePerpetual(): Perpetual {
+  return {
+    params: undefined,
+    fundingIndex: new Uint8Array(),
+    openInterest: new Uint8Array()
+  };
+}
+
+export const Perpetual = {
+  encode(message: Perpetual, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      PerpetualParams.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.fundingIndex.length !== 0) {
+      writer.uint32(18).bytes(message.fundingIndex);
+    }
+
+    if (message.openInterest.length !== 0) {
+      writer.uint32(26).bytes(message.openInterest);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Perpetual {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerpetual();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.params = PerpetualParams.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.fundingIndex = reader.bytes();
+          break;
+
+        case 3:
+          message.openInterest = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Perpetual>): Perpetual {
+    const message = createBasePerpetual();
+    message.params = object.params !== undefined && object.params !== null ? PerpetualParams.fromPartial(object.params) : undefined;
+    message.fundingIndex = object.fundingIndex ?? new Uint8Array();
+    message.openInterest = object.openInterest ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBasePerpetualParams(): PerpetualParams {
+  return {
+    id: 0,
+    ticker: "",
+    marketId: 0,
+    atomicResolution: 0,
+    defaultFundingPpm: 0,
+    liquidityTier: 0,
+    marketType: 0
+  };
+}
+
+export const PerpetualParams = {
+  encode(message: PerpetualParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.ticker !== "") {
+      writer.uint32(18).string(message.ticker);
+    }
+
+    if (message.marketId !== 0) {
+      writer.uint32(24).uint32(message.marketId);
+    }
+
+    if (message.atomicResolution !== 0) {
+      writer.uint32(32).sint32(message.atomicResolution);
+    }
+
+    if (message.defaultFundingPpm !== 0) {
+      writer.uint32(40).sint32(message.defaultFundingPpm);
+    }
+
+    if (message.liquidityTier !== 0) {
+      writer.uint32(48).uint32(message.liquidityTier);
+    }
+
+    if (message.marketType !== 0) {
+      writer.uint32(56).int32(message.marketType);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerpetualParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.ticker = reader.string();
+          break;
+
+        case 3:
+          message.marketId = reader.uint32();
+          break;
+
+        case 4:
+          message.atomicResolution = reader.sint32();
+          break;
+
+        case 5:
+          message.defaultFundingPpm = reader.sint32();
+          break;
+
+        case 6:
+          message.liquidityTier = reader.uint32();
+          break;
+
+        case 7:
+          message.marketType = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PerpetualParams>): PerpetualParams {
+    const message = createBasePerpetualParams();
+    message.id = object.id ?? 0;
+    message.ticker = object.ticker ?? "";
+    message.marketId = object.marketId ?? 0;
+    message.atomicResolution = object.atomicResolution ?? 0;
+    message.defaultFundingPpm = object.defaultFundingPpm ?? 0;
+    message.liquidityTier = object.liquidityTier ?? 0;
+    message.marketType = object.marketType ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseMarketPremiums(): MarketPremiums {
+  return {
+    perpetualId: 0,
+    premiums: []
+  };
+}
+
+export const MarketPremiums = {
+  encode(message: MarketPremiums, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.perpetualId !== 0) {
+      writer.uint32(8).uint32(message.perpetualId);
+    }
+
+    writer.uint32(18).fork();
+
+    for (const v of message.premiums) {
+      writer.sint32(v);
+    }
+
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MarketPremiums {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMarketPremiums();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.perpetualId = reader.uint32();
+          break;
+
+        case 2:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+
+            while (reader.pos < end2) {
+              message.premiums.push(reader.sint32());
+            }
+          } else {
+            message.premiums.push(reader.sint32());
+          }
+
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MarketPremiums>): MarketPremiums {
+    const message = createBaseMarketPremiums();
+    message.perpetualId = object.perpetualId ?? 0;
+    message.premiums = object.premiums?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBasePremiumStore(): PremiumStore {
+  return {
+    allMarketPremiums: [],
+    numPremiums: 0
+  };
+}
+
+export const PremiumStore = {
+  encode(message: PremiumStore, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.allMarketPremiums) {
+      MarketPremiums.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.numPremiums !== 0) {
+      writer.uint32(16).uint32(message.numPremiums);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PremiumStore {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePremiumStore();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.allMarketPremiums.push(MarketPremiums.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.numPremiums = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PremiumStore>): PremiumStore {
+    const message = createBasePremiumStore();
+    message.allMarketPremiums = object.allMarketPremiums?.map(e => MarketPremiums.fromPartial(e)) || [];
+    message.numPremiums = object.numPremiums ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseLiquidityTier(): LiquidityTier {
+  return {
+    id: 0,
+    name: "",
+    initialMarginPpm: 0,
+    maintenanceFractionPpm: 0,
+    basePositionNotional: Long.UZERO,
+    impactNotional: Long.UZERO,
+    openInterestLowerCap: Long.UZERO,
+    openInterestUpperCap: Long.UZERO
+  };
+}
+
+export const LiquidityTier = {
+  encode(message: LiquidityTier, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+
+    if (message.initialMarginPpm !== 0) {
+      writer.uint32(24).uint32(message.initialMarginPpm);
+    }
+
+    if (message.maintenanceFractionPpm !== 0) {
+      writer.uint32(32).uint32(message.maintenanceFractionPpm);
+    }
+
+    if (!message.basePositionNotional.isZero()) {
+      writer.uint32(40).uint64(message.basePositionNotional);
+    }
+
+    if (!message.impactNotional.isZero()) {
+      writer.uint32(48).uint64(message.impactNotional);
+    }
+
+    if (!message.openInterestLowerCap.isZero()) {
+      writer.uint32(56).uint64(message.openInterestLowerCap);
+    }
+
+    if (!message.openInterestUpperCap.isZero()) {
+      writer.uint32(64).uint64(message.openInterestUpperCap);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LiquidityTier {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLiquidityTier();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.name = reader.string();
+          break;
+
+        case 3:
+          message.initialMarginPpm = reader.uint32();
+          break;
+
+        case 4:
+          message.maintenanceFractionPpm = reader.uint32();
+          break;
+
+        case 5:
+          message.basePositionNotional = (reader.uint64() as Long);
+          break;
+
+        case 6:
+          message.impactNotional = (reader.uint64() as Long);
+          break;
+
+        case 7:
+          message.openInterestLowerCap = (reader.uint64() as Long);
+          break;
+
+        case 8:
+          message.openInterestUpperCap = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LiquidityTier>): LiquidityTier {
+    const message = createBaseLiquidityTier();
+    message.id = object.id ?? 0;
+    message.name = object.name ?? "";
+    message.initialMarginPpm = object.initialMarginPpm ?? 0;
+    message.maintenanceFractionPpm = object.maintenanceFractionPpm ?? 0;
+    message.basePositionNotional = object.basePositionNotional !== undefined && object.basePositionNotional !== null ? Long.fromValue(object.basePositionNotional) : Long.UZERO;
+    message.impactNotional = object.impactNotional !== undefined && object.impactNotional !== null ? Long.fromValue(object.impactNotional) : Long.UZERO;
+    message.openInterestLowerCap = object.openInterestLowerCap !== undefined && object.openInterestLowerCap !== null ? Long.fromValue(object.openInterestLowerCap) : Long.UZERO;
+    message.openInterestUpperCap = object.openInterestUpperCap !== undefined && object.openInterestUpperCap !== null ? Long.fromValue(object.openInterestUpperCap) : Long.UZERO;
+    return message;
+  }
+
+};