@zoguxprotocol/proto 0.1.0

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

@@ -0,0 +1,396 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+/** Status of the CLOB. */
+
+export enum ClobPair_Status {
+  /** STATUS_UNSPECIFIED - Default value. This value is invalid and unused. */
+  STATUS_UNSPECIFIED = 0,
+
+  /** STATUS_ACTIVE - STATUS_ACTIVE represents an active clob pair. */
+  STATUS_ACTIVE = 1,
+
+  /**
+   * STATUS_PAUSED - STATUS_PAUSED behavior is unfinalized.
+   * TODO(DEC-600): update this documentation.
+   */
+  STATUS_PAUSED = 2,
+
+  /**
+   * STATUS_CANCEL_ONLY - STATUS_CANCEL_ONLY behavior is unfinalized.
+   * TODO(DEC-600): update this documentation.
+   */
+  STATUS_CANCEL_ONLY = 3,
+
+  /**
+   * STATUS_POST_ONLY - STATUS_POST_ONLY behavior is unfinalized.
+   * TODO(DEC-600): update this documentation.
+   */
+  STATUS_POST_ONLY = 4,
+
+  /**
+   * STATUS_INITIALIZING - STATUS_INITIALIZING represents a newly-added clob pair.
+   * Clob pairs in this state only accept orders which are
+   * both short-term and post-only.
+   */
+  STATUS_INITIALIZING = 5,
+
+  /**
+   * STATUS_FINAL_SETTLEMENT - STATUS_FINAL_SETTLEMENT represents a clob pair which is deactivated
+   * and trading has ceased. All open positions will be closed by the
+   * protocol. Open stateful orders will be cancelled. Open short-term
+   * orders will be left to expire.
+   */
+  STATUS_FINAL_SETTLEMENT = 6,
+  UNRECOGNIZED = -1,
+}
+export const ClobPair_StatusSDKType = ClobPair_Status;
+export function clobPair_StatusFromJSON(object: any): ClobPair_Status {
+  switch (object) {
+    case 0:
+    case "STATUS_UNSPECIFIED":
+      return ClobPair_Status.STATUS_UNSPECIFIED;
+
+    case 1:
+    case "STATUS_ACTIVE":
+      return ClobPair_Status.STATUS_ACTIVE;
+
+    case 2:
+    case "STATUS_PAUSED":
+      return ClobPair_Status.STATUS_PAUSED;
+
+    case 3:
+    case "STATUS_CANCEL_ONLY":
+      return ClobPair_Status.STATUS_CANCEL_ONLY;
+
+    case 4:
+    case "STATUS_POST_ONLY":
+      return ClobPair_Status.STATUS_POST_ONLY;
+
+    case 5:
+    case "STATUS_INITIALIZING":
+      return ClobPair_Status.STATUS_INITIALIZING;
+
+    case 6:
+    case "STATUS_FINAL_SETTLEMENT":
+      return ClobPair_Status.STATUS_FINAL_SETTLEMENT;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ClobPair_Status.UNRECOGNIZED;
+  }
+}
+export function clobPair_StatusToJSON(object: ClobPair_Status): string {
+  switch (object) {
+    case ClobPair_Status.STATUS_UNSPECIFIED:
+      return "STATUS_UNSPECIFIED";
+
+    case ClobPair_Status.STATUS_ACTIVE:
+      return "STATUS_ACTIVE";
+
+    case ClobPair_Status.STATUS_PAUSED:
+      return "STATUS_PAUSED";
+
+    case ClobPair_Status.STATUS_CANCEL_ONLY:
+      return "STATUS_CANCEL_ONLY";
+
+    case ClobPair_Status.STATUS_POST_ONLY:
+      return "STATUS_POST_ONLY";
+
+    case ClobPair_Status.STATUS_INITIALIZING:
+      return "STATUS_INITIALIZING";
+
+    case ClobPair_Status.STATUS_FINAL_SETTLEMENT:
+      return "STATUS_FINAL_SETTLEMENT";
+
+    case ClobPair_Status.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Perpetual product.
+ */
+
+export interface PerpetualClobMetadata {
+  /** Id of the Perpetual the CLOB allows trading of. */
+  perpetualId: number;
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Perpetual product.
+ */
+
+export interface PerpetualClobMetadataSDKType {
+  perpetual_id: number;
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Spot product.
+ */
+
+export interface SpotClobMetadata {
+  /** Id of the base Asset in the trading pair. */
+  baseAssetId: number;
+  /** Id of the quote Asset in the trading pair. */
+
+  quoteAssetId: number;
+}
+/**
+ * PerpetualClobMetadata contains metadata for a `ClobPair`
+ * representing a Spot product.
+ */
+
+export interface SpotClobMetadataSDKType {
+  base_asset_id: number;
+  quote_asset_id: number;
+}
+/**
+ * ClobPair represents a single CLOB pair for a given product
+ * in state.
+ */
+
+export interface ClobPair {
+  /** ID of the orderbook that stores all resting liquidity for this CLOB. */
+  id: number;
+  perpetualClobMetadata?: PerpetualClobMetadata;
+  spotClobMetadata?: SpotClobMetadata;
+  /** Minimum increment in the size of orders on the CLOB, in base quantums. */
+
+  stepBaseQuantums: Long;
+  /**
+   * Defines the tick size of the orderbook by defining how many subticks
+   * are in one tick. That is, the subticks of any valid order must be a
+   * multiple of this value. Generally this value should start `>= 100`to
+   * allow room for decreasing it.
+   */
+
+  subticksPerTick: number;
+  /**
+   * `10^Exponent` gives the number of QuoteQuantums traded per BaseQuantum
+   * per Subtick.
+   */
+
+  quantumConversionExponent: number;
+  status: ClobPair_Status;
+}
+/**
+ * ClobPair represents a single CLOB pair for a given product
+ * in state.
+ */
+
+export interface ClobPairSDKType {
+  id: number;
+  perpetual_clob_metadata?: PerpetualClobMetadataSDKType;
+  spot_clob_metadata?: SpotClobMetadataSDKType;
+  step_base_quantums: Long;
+  subticks_per_tick: number;
+  quantum_conversion_exponent: number;
+  status: ClobPair_Status;
+}
+
+function createBasePerpetualClobMetadata(): PerpetualClobMetadata {
+  return {
+    perpetualId: 0
+  };
+}
+
+export const PerpetualClobMetadata = {
+  encode(message: PerpetualClobMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.perpetualId !== 0) {
+      writer.uint32(8).uint32(message.perpetualId);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualClobMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerpetualClobMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.perpetualId = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PerpetualClobMetadata>): PerpetualClobMetadata {
+    const message = createBasePerpetualClobMetadata();
+    message.perpetualId = object.perpetualId ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseSpotClobMetadata(): SpotClobMetadata {
+  return {
+    baseAssetId: 0,
+    quoteAssetId: 0
+  };
+}
+
+export const SpotClobMetadata = {
+  encode(message: SpotClobMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.baseAssetId !== 0) {
+      writer.uint32(8).uint32(message.baseAssetId);
+    }
+
+    if (message.quoteAssetId !== 0) {
+      writer.uint32(16).uint32(message.quoteAssetId);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SpotClobMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSpotClobMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAssetId = reader.uint32();
+          break;
+
+        case 2:
+          message.quoteAssetId = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SpotClobMetadata>): SpotClobMetadata {
+    const message = createBaseSpotClobMetadata();
+    message.baseAssetId = object.baseAssetId ?? 0;
+    message.quoteAssetId = object.quoteAssetId ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseClobPair(): ClobPair {
+  return {
+    id: 0,
+    perpetualClobMetadata: undefined,
+    spotClobMetadata: undefined,
+    stepBaseQuantums: Long.UZERO,
+    subticksPerTick: 0,
+    quantumConversionExponent: 0,
+    status: 0
+  };
+}
+
+export const ClobPair = {
+  encode(message: ClobPair, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.perpetualClobMetadata !== undefined) {
+      PerpetualClobMetadata.encode(message.perpetualClobMetadata, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.spotClobMetadata !== undefined) {
+      SpotClobMetadata.encode(message.spotClobMetadata, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (!message.stepBaseQuantums.isZero()) {
+      writer.uint32(32).uint64(message.stepBaseQuantums);
+    }
+
+    if (message.subticksPerTick !== 0) {
+      writer.uint32(40).uint32(message.subticksPerTick);
+    }
+
+    if (message.quantumConversionExponent !== 0) {
+      writer.uint32(48).sint32(message.quantumConversionExponent);
+    }
+
+    if (message.status !== 0) {
+      writer.uint32(56).int32(message.status);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ClobPair {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClobPair();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.perpetualClobMetadata = PerpetualClobMetadata.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.spotClobMetadata = SpotClobMetadata.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.stepBaseQuantums = (reader.uint64() as Long);
+          break;
+
+        case 5:
+          message.subticksPerTick = reader.uint32();
+          break;
+
+        case 6:
+          message.quantumConversionExponent = reader.sint32();
+          break;
+
+        case 7:
+          message.status = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ClobPair>): ClobPair {
+    const message = createBaseClobPair();
+    message.id = object.id ?? 0;
+    message.perpetualClobMetadata = object.perpetualClobMetadata !== undefined && object.perpetualClobMetadata !== null ? PerpetualClobMetadata.fromPartial(object.perpetualClobMetadata) : undefined;
+    message.spotClobMetadata = object.spotClobMetadata !== undefined && object.spotClobMetadata !== null ? SpotClobMetadata.fromPartial(object.spotClobMetadata) : undefined;
+    message.stepBaseQuantums = object.stepBaseQuantums !== undefined && object.stepBaseQuantums !== null ? Long.fromValue(object.stepBaseQuantums) : Long.UZERO;
+    message.subticksPerTick = object.subticksPerTick ?? 0;
+    message.quantumConversionExponent = object.quantumConversionExponent ?? 0;
+    message.status = object.status ?? 0;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,154 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * Defines the set of equity tiers to limit how many open orders
+ * a subaccount is allowed to have.
+ */
+
+export interface EquityTierLimitConfiguration {
+  /**
+   * How many short term stateful orders are allowed per equity tier.
+   * Specifying 0 values disables this limit.
+   */
+  shortTermOrderEquityTiers: EquityTierLimit[];
+  /**
+   * How many open stateful orders are allowed per equity tier.
+   * Specifying 0 values disables this limit.
+   */
+
+  statefulOrderEquityTiers: EquityTierLimit[];
+}
+/**
+ * Defines the set of equity tiers to limit how many open orders
+ * a subaccount is allowed to have.
+ */
+
+export interface EquityTierLimitConfigurationSDKType {
+  short_term_order_equity_tiers: EquityTierLimitSDKType[];
+  stateful_order_equity_tiers: EquityTierLimitSDKType[];
+}
+/** Defines an equity tier limit. */
+
+export interface EquityTierLimit {
+  /** The total net collateral in USDC quote quantums of equity required. */
+  usdTncRequired: Uint8Array;
+  /** What the limit is for `usd_tnc_required`. */
+
+  limit: number;
+}
+/** Defines an equity tier limit. */
+
+export interface EquityTierLimitSDKType {
+  usd_tnc_required: Uint8Array;
+  limit: number;
+}
+
+function createBaseEquityTierLimitConfiguration(): EquityTierLimitConfiguration {
+  return {
+    shortTermOrderEquityTiers: [],
+    statefulOrderEquityTiers: []
+  };
+}
+
+export const EquityTierLimitConfiguration = {
+  encode(message: EquityTierLimitConfiguration, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.shortTermOrderEquityTiers) {
+      EquityTierLimit.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.statefulOrderEquityTiers) {
+      EquityTierLimit.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EquityTierLimitConfiguration {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEquityTierLimitConfiguration();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.shortTermOrderEquityTiers.push(EquityTierLimit.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.statefulOrderEquityTiers.push(EquityTierLimit.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<EquityTierLimitConfiguration>): EquityTierLimitConfiguration {
+    const message = createBaseEquityTierLimitConfiguration();
+    message.shortTermOrderEquityTiers = object.shortTermOrderEquityTiers?.map(e => EquityTierLimit.fromPartial(e)) || [];
+    message.statefulOrderEquityTiers = object.statefulOrderEquityTiers?.map(e => EquityTierLimit.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseEquityTierLimit(): EquityTierLimit {
+  return {
+    usdTncRequired: new Uint8Array(),
+    limit: 0
+  };
+}
+
+export const EquityTierLimit = {
+  encode(message: EquityTierLimit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.usdTncRequired.length !== 0) {
+      writer.uint32(10).bytes(message.usdTncRequired);
+    }
+
+    if (message.limit !== 0) {
+      writer.uint32(16).uint32(message.limit);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EquityTierLimit {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEquityTierLimit();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.usdTncRequired = reader.bytes();
+          break;
+
+        case 2:
+          message.limit = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<EquityTierLimit>): EquityTierLimit {
+    const message = createBaseEquityTierLimit();
+    message.usdTncRequired = object.usdTncRequired ?? new Uint8Array();
+    message.limit = object.limit ?? 0;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,65 @@
+import { ClobPair, ClobPairSDKType } from "./clob_pair";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+ * FinalizeBlock.
+ */
+
+export interface ClobStagedFinalizeBlockEvent {
+  /** create_clob_pair indicates a new CLOB pair creation. */
+  createClobPair?: ClobPair;
+}
+/**
+ * ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+ * FinalizeBlock.
+ */
+
+export interface ClobStagedFinalizeBlockEventSDKType {
+  create_clob_pair?: ClobPairSDKType;
+}
+
+function createBaseClobStagedFinalizeBlockEvent(): ClobStagedFinalizeBlockEvent {
+  return {
+    createClobPair: undefined
+  };
+}
+
+export const ClobStagedFinalizeBlockEvent = {
+  encode(message: ClobStagedFinalizeBlockEvent, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.createClobPair !== undefined) {
+      ClobPair.encode(message.createClobPair, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ClobStagedFinalizeBlockEvent {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClobStagedFinalizeBlockEvent();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.createClobPair = ClobPair.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ClobStagedFinalizeBlockEvent>): ClobStagedFinalizeBlockEvent {
+    const message = createBaseClobStagedFinalizeBlockEvent();
+    message.createClobPair = object.createClobPair !== undefined && object.createClobPair !== null ? ClobPair.fromPartial(object.createClobPair) : undefined;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,97 @@
+import { ClobPair, ClobPairSDKType } from "./clob_pair";
+import { LiquidationsConfig, LiquidationsConfigSDKType } from "./liquidations_config";
+import { BlockRateLimitConfiguration, BlockRateLimitConfigurationSDKType } from "./block_rate_limit_config";
+import { EquityTierLimitConfiguration, EquityTierLimitConfigurationSDKType } from "./equity_tier_limit_config";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the clob module's genesis state. */
+
+export interface GenesisState {
+  clobPairs: ClobPair[];
+  liquidationsConfig?: LiquidationsConfig;
+  blockRateLimitConfig?: BlockRateLimitConfiguration;
+  equityTierLimitConfig?: EquityTierLimitConfiguration;
+}
+/** GenesisState defines the clob module's genesis state. */
+
+export interface GenesisStateSDKType {
+  clob_pairs: ClobPairSDKType[];
+  liquidations_config?: LiquidationsConfigSDKType;
+  block_rate_limit_config?: BlockRateLimitConfigurationSDKType;
+  equity_tier_limit_config?: EquityTierLimitConfigurationSDKType;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    clobPairs: [],
+    liquidationsConfig: undefined,
+    blockRateLimitConfig: undefined,
+    equityTierLimitConfig: undefined
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.clobPairs) {
+      ClobPair.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.liquidationsConfig !== undefined) {
+      LiquidationsConfig.encode(message.liquidationsConfig, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.blockRateLimitConfig !== undefined) {
+      BlockRateLimitConfiguration.encode(message.blockRateLimitConfig, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.equityTierLimitConfig !== undefined) {
+      EquityTierLimitConfiguration.encode(message.equityTierLimitConfig, writer.uint32(34).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.clobPairs.push(ClobPair.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.liquidationsConfig = LiquidationsConfig.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.blockRateLimitConfig = BlockRateLimitConfiguration.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.equityTierLimitConfig = EquityTierLimitConfiguration.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.clobPairs = object.clobPairs?.map(e => ClobPair.fromPartial(e)) || [];
+    message.liquidationsConfig = object.liquidationsConfig !== undefined && object.liquidationsConfig !== null ? LiquidationsConfig.fromPartial(object.liquidationsConfig) : undefined;
+    message.blockRateLimitConfig = object.blockRateLimitConfig !== undefined && object.blockRateLimitConfig !== null ? BlockRateLimitConfiguration.fromPartial(object.blockRateLimitConfig) : undefined;
+    message.equityTierLimitConfig = object.equityTierLimitConfig !== undefined && object.equityTierLimitConfig !== null ? EquityTierLimitConfiguration.fromPartial(object.equityTierLimitConfig) : undefined;
+    return message;
+  }
+
+};