add volatility_bounds_period to LiquidityTier proto and add Volatilit…

…yBounds proto

indexer/packages/v4-protos/src/codegen/dydxprotocol/perpetuals/perpetual.ts

@@ -1,3 +1,4 @@
+import { Duration, DurationSDKType } from "../../google/protobuf/duration";
 import * as _m0 from "protobufjs/minimal";
 import { DeepPartial, Long } from "../../helpers";
 /** Perpetual represents a perpetual on the dYdX exchange. */
@@ -212,6 +213,12 @@ export interface LiquidityTier {
    */
 
   impactNotional: Long;
+  /**
+   * This duration specifies how fast volatility bounds recover.
+   * A longer duration leads to a longer (slower) recovery time.
+   */
+
+  volatilityBoundsPeriod?: Duration;
 }
 /** LiquidityTier stores margin information. */
 
@@ -251,6 +258,36 @@ export interface LiquidityTierSDKType {
    */
 
   impact_notional: Long;
+  /**
+   * This duration specifies how fast volatility bounds recover.
+   * A longer duration leads to a longer (slower) recovery time.
+   */
+
+  volatility_bounds_period?: DurationSDKType;
+}
+/**
+ * VolatilityBounds stores lower and upper bounds of volatility for a perpeutal.
+ * A perpetual's variable margin fraction is computed with
+ * `VolatilityBounds.Min` and `VolatilityBounds.Max` as (let `o` be oracle price
+ * of the corresponding market and `mmf` be margin maintenance fraction):
+ * max((VolatilityBounds.Max - o) / o, (o - VolatilityBounds.Min) / o) + mmf
+ */
+
+export interface VolatilityBounds {
+  min: Long;
+  max: Long;
+}
+/**
+ * VolatilityBounds stores lower and upper bounds of volatility for a perpeutal.
+ * A perpetual's variable margin fraction is computed with
+ * `VolatilityBounds.Min` and `VolatilityBounds.Max` as (let `o` be oracle price
+ * of the corresponding market and `mmf` be margin maintenance fraction):
+ * max((VolatilityBounds.Max - o) / o, (o - VolatilityBounds.Min) / o) + mmf
+ */
+
+export interface VolatilityBoundsSDKType {
+  min: Long;
+  max: Long;
 }
 
 function createBasePerpetual(): Perpetual {
@@ -532,7 +569,8 @@ function createBaseLiquidityTier(): LiquidityTier {
     initialMarginPpm: 0,
     maintenanceFractionPpm: 0,
     basePositionNotional: Long.UZERO,
-    impactNotional: Long.UZERO
+    impactNotional: Long.UZERO,
+    volatilityBoundsPeriod: undefined
   };
 }
 
@@ -562,6 +600,10 @@ export const LiquidityTier = {
       writer.uint32(48).uint64(message.impactNotional);
     }
 
+    if (message.volatilityBoundsPeriod !== undefined) {
+      Duration.encode(message.volatilityBoundsPeriod, writer.uint32(58).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -598,6 +640,10 @@ export const LiquidityTier = {
           message.impactNotional = (reader.uint64() as Long);
           break;
 
+        case 7:
+          message.volatilityBoundsPeriod = Duration.decode(reader, reader.uint32());
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -615,6 +661,62 @@ export const LiquidityTier = {
     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.volatilityBoundsPeriod = object.volatilityBoundsPeriod !== undefined && object.volatilityBoundsPeriod !== null ? Duration.fromPartial(object.volatilityBoundsPeriod) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseVolatilityBounds(): VolatilityBounds {
+  return {
+    min: Long.UZERO,
+    max: Long.UZERO
+  };
+}
+
+export const VolatilityBounds = {
+  encode(message: VolatilityBounds, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.min.isZero()) {
+      writer.uint32(8).uint64(message.min);
+    }
+
+    if (!message.max.isZero()) {
+      writer.uint32(16).uint64(message.max);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): VolatilityBounds {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVolatilityBounds();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.min = (reader.uint64() as Long);
+          break;
+
+        case 2:
+          message.max = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<VolatilityBounds>): VolatilityBounds {
+    const message = createBaseVolatilityBounds();
+    message.min = object.min !== undefined && object.min !== null ? Long.fromValue(object.min) : Long.UZERO;
+    message.max = object.max !== undefined && object.max !== null ? Long.fromValue(object.max) : Long.UZERO;
     return message;
   }
 

proto/dydxprotocol/perpetuals/perpetual.proto

@@ -2,6 +2,7 @@ syntax = "proto3";
 package dydxprotocol.perpetuals;
 
 import "gogoproto/gogo.proto";
+import "google/protobuf/duration.proto";
 
 option go_package = "github.com/dydxprotocol/v4-chain/protocol/x/perpetuals/types";
 
@@ -106,4 +107,19 @@ message LiquidityTier {
   // - Impact ask price = average execution price for a market buy of the
   // impact notional value.
   uint64 impact_notional = 6;
+
+  // This duration specifies how fast volatility bounds recover.
+  // A longer duration leads to a longer (slower) recovery time.
+  google.protobuf.Duration volatility_bounds_period = 7
+      [ (gogoproto.nullable) = false, (gogoproto.stdduration) = true ];
+}
+
+// VolatilityBounds stores lower and upper bounds of volatility for a perpeutal.
+// A perpetual's variable margin fraction is computed with
+// `VolatilityBounds.Min` and `VolatilityBounds.Max` as (let `o` be oracle price
+// of the corresponding market and `mmf` be margin maintenance fraction):
+// max((VolatilityBounds.Max - o) / o, (o - VolatilityBounds.Min) / o) + mmf
+message VolatilityBounds {
+  uint64 min = 1;
+  uint64 max = 2;
 }