@polyester/sdk 0.7.0 → 0.8.0

package/dist/services/policies/subaccount-policies/subaccount-policies.schemas.d.ts

@@ -38,27 +38,12 @@ declare const SubaccountPolicySchema: v.SchemaWithPipe<readonly [v.ObjectSchema<
     readonly symbol: v.StringSchema<undefined>;
   }, undefined>, undefined>, readonly []>;
   readonly spotMarketScope: v.SchemaWithPipe<readonly [v.EnumSchema<typeof MarketScope_Value, undefined>, v.TransformAction<MarketScope_Value, DecodedEnum<"all" | "allowlist">>]>;
-  readonly perpMarketScope: v.SchemaWithPipe<readonly [v.EnumSchema<typeof MarketScope_Value, undefined>, v.TransformAction<MarketScope_Value, DecodedEnum<"all" | "allowlist">>]>;
-  readonly perpMarkets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-    readonly symbol: v.StringSchema<undefined>;
-    readonly maxLeverageX: v.NumberSchema<undefined>;
-  }, undefined>, undefined>, readonly []>;
-  readonly actions: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.EnumSchema<typeof PolicyAction, undefined>, undefined>, readonly []>, v.TransformAction<v.EnumValues<typeof PolicyAction>[], DecodedEnum<"trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists">[]>]>;
+  readonly actions: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.EnumSchema<typeof PolicyAction, undefined>, undefined>, readonly []>, v.TransformAction<v.EnumValues<typeof PolicyAction>[], DecodedEnum<"trade-spot" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-internal-transfers" | "read-address-book" | "manage-address-book">[]>]>;
   readonly isTemplate: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
   readonly sourceTemplateId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
-  readonly globalNotionalCap: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
   readonly maxOrderNotional: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
   readonly maxOpenOrders: v.NumberSchema<undefined>;
-  readonly maxOpenPositions: v.NumberSchema<undefined>;
-  readonly globalPerpLeverageX: v.NumberSchema<undefined>;
-  readonly dailyInternalTransferOutLimit: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
-  readonly dailyWithdrawLimit: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
-  readonly internalTransfersOwnOnly: v.BooleanSchema<undefined>;
-  readonly enforceWithdrawWhitelist: v.BooleanSchema<undefined>;
   readonly tradingHalted: v.BooleanSchema<undefined>;
-  readonly liquidationOnly: v.BooleanSchema<undefined>;
-  readonly dailyLossLimit: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
-  readonly intradayDrawdownLimitBps: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, number>]>;
   readonly locked: v.BooleanSchema<undefined>;
   readonly reviewAt: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ObjectSchema<{
     readonly seconds: v.BigintSchema<undefined>;
@@ -94,27 +79,12 @@ declare const SubaccountPolicySchema: v.SchemaWithPipe<readonly [v.ObjectSchema<
     symbol: string;
   }[];
   spotMarketScope: DecodedEnum<"all" | "allowlist">;
-  perpMarketScope: DecodedEnum<"all" | "allowlist">;
-  perpMarkets: {
-    symbol: string;
-    maxLeverageX: number;
-  }[];
-  actions: DecodedEnum<"trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists">[];
+  actions: DecodedEnum<"trade-spot" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-internal-transfers" | "read-address-book" | "manage-address-book">[];
   isTemplate: boolean;
   sourceTemplateId?: string | undefined;
-  globalNotionalCap: number;
   maxOrderNotional: number;
   maxOpenOrders: number;
-  maxOpenPositions: number;
-  globalPerpLeverageX: number;
-  dailyInternalTransferOutLimit: number;
-  dailyWithdrawLimit: number;
-  internalTransfersOwnOnly: boolean;
-  enforceWithdrawWhitelist: boolean;
   tradingHalted: boolean;
-  liquidationOnly: boolean;
-  dailyLossLimit: number;
-  intradayDrawdownLimitBps: number;
   locked: boolean;
   reviewAt?: number | undefined;
   expiresAt?: number | undefined;
@@ -134,32 +104,17 @@ declare const SubaccountPolicySchema: v.SchemaWithPipe<readonly [v.ObjectSchema<
     symbol: string;
   }[];
   spotMarketScope: DecodedEnum<"all" | "allowlist">;
-  perpMarketScope: DecodedEnum<"all" | "allowlist">;
-  perpMarkets: {
-    symbol: string;
-    maxLeverageX: number;
-  }[];
-  actions: DecodedEnum<"trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists">[];
+  actions: DecodedEnum<"trade-spot" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-internal-transfers" | "read-address-book" | "manage-address-book">[];
   isTemplate: boolean;
   sourceTemplateId?: string | undefined;
   maxOpenOrders: number;
-  maxOpenPositions: number;
-  globalPerpLeverageX: number;
-  dailyInternalTransferOutLimit: number;
-  dailyWithdrawLimit: number;
-  internalTransfersOwnOnly: boolean;
-  enforceWithdrawWhitelist: boolean;
   tradingHalted: boolean;
-  liquidationOnly: boolean;
-  dailyLossLimit: number;
   locked: boolean;
   reviewAt?: number | undefined;
   expiresAt?: number | undefined;
   createdAt: number;
   revision: string;
   maxOrderSize: number;
-  globalExposureCap: number;
-  intradayDrawdownLimitPct: number;
 }>]>;
 type SubaccountPolicy = v.InferOutput<typeof SubaccountPolicySchema>;
 declare const CreateSubaccountPolicyInputSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
@@ -168,97 +123,33 @@ declare const CreateSubaccountPolicyInputSchema: v.SchemaWithPipe<readonly [v.St
   readonly spotMarkets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
     readonly symbol: v.StringSchema<undefined>;
   }, undefined>, undefined>, readonly []>;
-  readonly perpMarkets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-    readonly symbol: v.StringSchema<undefined>;
-    readonly maxLeverageX: v.NumberSchema<undefined>;
-  }, undefined>, undefined>, readonly []>;
   readonly spotMarketScope: v.SchemaWithPipe<readonly [v.PicklistSchema<readonly ["all", "allowlist"], undefined>, v.TransformAction<"all" | "allowlist", MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST>]>;
-  readonly perpMarketScope: v.SchemaWithPipe<readonly [v.PicklistSchema<readonly ["all", "allowlist"], undefined>, v.TransformAction<"all" | "allowlist", MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST>]>;
-  readonly actions: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["trade-spot", "trade-perp", "internal-transfer", "external-withdraw", "read-balances", "read-spot", "read-perp", "read-internal-transfers", "read-external-withdrawals", "read-transfer-controls", "manage-address-book", "manage-transfer-whitelists"], undefined>, undefined>, readonly ["read-balances", "read-spot"]>, v.TransformAction<("trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists")[], (PolicyAction.TRADE_SPOT | PolicyAction.TRADE_PERP | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_PERP | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_EXTERNAL_WITHDRAWALS | PolicyAction.READ_TRANSFER_CONTROLS | PolicyAction.MANAGE_ADDRESS_BOOK | PolicyAction.MANAGE_TRANSFER_WHITELISTS)[]>]>;
-  readonly globalLeverageCap: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, number>]>;
-  readonly globalExposureCap: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, bigint>]>;
+  readonly actions: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["trade-spot", "internal-transfer", "external-withdraw", "read-balances", "read-spot", "read-internal-transfers", "read-address-book", "manage-address-book"], undefined>, undefined>, readonly []>, v.TransformAction<("trade-spot" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-internal-transfers" | "read-address-book" | "manage-address-book")[], (PolicyAction.TRADE_SPOT | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_ADDRESS_BOOK | PolicyAction.MANAGE_ADDRESS_BOOK)[]>]>;
   readonly maxOrderSize: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, bigint>]>;
   readonly maxOpenOrders: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, number>]>;
-  readonly maxOpenPositions: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, number>]>;
-  readonly dailyInternalTransferLimit: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, bigint>]>;
-  readonly dailyWithdrawLimit: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, bigint>]>;
-  readonly dailyLossLimit: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, bigint>]>;
-  readonly intradayDrawdownLimitPct: v.SchemaWithPipe<readonly [v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, null>, v.TransformAction<number | null, number>]>;
   readonly tradingHalted: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
-  readonly liquidationOnly: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
   readonly policyLocked: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
-  readonly internalTransfersOwnOnly: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
-  readonly enforceWithdrawWhitelist: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
   readonly reviewAt: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
   readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
   readonly subaccountId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
-}, undefined>, v.CheckAction<{
+}, undefined>, v.TransformAction<{
   name: string;
   description: string;
   spotMarkets: {
     symbol: string;
   }[];
-  perpMarkets: {
-    symbol: string;
-    maxLeverageX: number;
-  }[];
   spotMarketScope: MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST;
-  perpMarketScope: MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST;
-  actions: (PolicyAction.TRADE_SPOT | PolicyAction.TRADE_PERP | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_PERP | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_EXTERNAL_WITHDRAWALS | PolicyAction.READ_TRANSFER_CONTROLS | PolicyAction.MANAGE_ADDRESS_BOOK | PolicyAction.MANAGE_TRANSFER_WHITELISTS)[];
-  globalLeverageCap: number;
-  globalExposureCap: bigint;
+  actions: (PolicyAction.TRADE_SPOT | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_ADDRESS_BOOK | PolicyAction.MANAGE_ADDRESS_BOOK)[];
   maxOrderSize: bigint;
   maxOpenOrders: number;
-  maxOpenPositions: number;
-  dailyInternalTransferLimit: bigint;
-  dailyWithdrawLimit: bigint;
-  dailyLossLimit: bigint;
-  intradayDrawdownLimitPct: number;
   tradingHalted: boolean;
-  liquidationOnly: boolean;
   policyLocked: boolean;
-  internalTransfersOwnOnly: boolean;
-  enforceWithdrawWhitelist: boolean;
-  reviewAt?: number | null | undefined;
-  expiresAt?: number | null | undefined;
-  subaccountId?: bigint | undefined;
-}, "Subaccount policy actions must include read-balances and read-spot">, v.TransformAction<{
-  name: string;
-  description: string;
-  spotMarkets: {
-    symbol: string;
-  }[];
-  perpMarkets: {
-    symbol: string;
-    maxLeverageX: number;
-  }[];
-  spotMarketScope: MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST;
-  perpMarketScope: MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST;
-  actions: (PolicyAction.TRADE_SPOT | PolicyAction.TRADE_PERP | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_PERP | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_EXTERNAL_WITHDRAWALS | PolicyAction.READ_TRANSFER_CONTROLS | PolicyAction.MANAGE_ADDRESS_BOOK | PolicyAction.MANAGE_TRANSFER_WHITELISTS)[];
-  globalLeverageCap: number;
-  globalExposureCap: bigint;
-  maxOrderSize: bigint;
-  maxOpenOrders: number;
-  maxOpenPositions: number;
-  dailyInternalTransferLimit: bigint;
-  dailyWithdrawLimit: bigint;
-  dailyLossLimit: bigint;
-  intradayDrawdownLimitPct: number;
-  tradingHalted: boolean;
-  liquidationOnly: boolean;
-  policyLocked: boolean;
-  internalTransfersOwnOnly: boolean;
-  enforceWithdrawWhitelist: boolean;
   reviewAt?: number | null | undefined;
   expiresAt?: number | null | undefined;
   subaccountId?: bigint | undefined;
 }, {
   policy: {
-    globalNotionalCap: bigint;
     maxOrderNotional: bigint;
-    globalPerpLeverageX: number;
-    dailyInternalTransferOutLimit: bigint;
-    intradayDrawdownLimitBps: number;
     locked: boolean;
     reviewAt: import("@bufbuild/protobuf/wkt").Timestamp | undefined;
     expiresAt: import("@bufbuild/protobuf/wkt").Timestamp | undefined;
@@ -267,21 +158,10 @@ declare const CreateSubaccountPolicyInputSchema: v.SchemaWithPipe<readonly [v.St
     spotMarkets: {
       symbol: string;
     }[];
-    perpMarkets: {
-      symbol: string;
-      maxLeverageX: number;
-    }[];
     spotMarketScope: MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST;
-    perpMarketScope: MarketScope_Value.ALL | MarketScope_Value.ALLOWLIST;
-    actions: (PolicyAction.TRADE_SPOT | PolicyAction.TRADE_PERP | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_PERP | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_EXTERNAL_WITHDRAWALS | PolicyAction.READ_TRANSFER_CONTROLS | PolicyAction.MANAGE_ADDRESS_BOOK | PolicyAction.MANAGE_TRANSFER_WHITELISTS)[];
+    actions: (PolicyAction.TRADE_SPOT | PolicyAction.INTERNAL_TRANSFER | PolicyAction.EXTERNAL_WITHDRAW | PolicyAction.READ_BALANCES | PolicyAction.READ_SPOT | PolicyAction.READ_INTERNAL_TRANSFERS | PolicyAction.READ_ADDRESS_BOOK | PolicyAction.MANAGE_ADDRESS_BOOK)[];
     maxOpenOrders: number;
-    maxOpenPositions: number;
-    dailyWithdrawLimit: bigint;
-    dailyLossLimit: bigint;
     tradingHalted: boolean;
-    liquidationOnly: boolean;
-    internalTransfersOwnOnly: boolean;
-    enforceWithdrawWhitelist: boolean;
   };
   subaccountId: bigint | undefined;
 }>]>;
@@ -294,27 +174,12 @@ declare const UpdateSubaccountPolicyInputSchema: v.SchemaWithPipe<readonly [v.St
   readonly spotMarkets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
     readonly symbol: v.StringSchema<undefined>;
   }, undefined>, undefined>, undefined>;
-  readonly perpMarkets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-    readonly symbol: v.StringSchema<undefined>;
-    readonly maxLeverageX: v.NumberSchema<undefined>;
-  }, undefined>, undefined>, undefined>;
   readonly spotMarketScope: v.OptionalSchema<v.PicklistSchema<readonly ["all", "allowlist"], undefined>, undefined>;
-  readonly perpMarketScope: v.OptionalSchema<v.PicklistSchema<readonly ["all", "allowlist"], undefined>, undefined>;
-  readonly actions: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["trade-spot", "trade-perp", "internal-transfer", "external-withdraw", "read-balances", "read-spot", "read-perp", "read-internal-transfers", "read-external-withdrawals", "read-transfer-controls", "manage-address-book", "manage-transfer-whitelists"], undefined>, undefined>, undefined>;
-  readonly globalLeverageCap: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-  readonly globalExposureCap: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+  readonly actions: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["trade-spot", "internal-transfer", "external-withdraw", "read-balances", "read-spot", "read-internal-transfers", "read-address-book", "manage-address-book"], undefined>, undefined>, undefined>;
   readonly maxOrderSize: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
   readonly maxOpenOrders: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-  readonly maxOpenPositions: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-  readonly dailyInternalTransferLimit: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-  readonly dailyWithdrawLimit: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-  readonly dailyLossLimit: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-  readonly intradayDrawdownLimitPct: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
   readonly tradingHalted: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-  readonly liquidationOnly: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
   readonly policyLocked: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-  readonly internalTransfersOwnOnly: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-  readonly enforceWithdrawWhitelist: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
   readonly reviewAt: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
   readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
 }, undefined>, v.CheckAction<{
@@ -325,58 +190,12 @@ declare const UpdateSubaccountPolicyInputSchema: v.SchemaWithPipe<readonly [v.St
   spotMarkets?: {
     symbol: string;
   }[] | undefined;
-  perpMarkets?: {
-    symbol: string;
-    maxLeverageX: number;
-  }[] | undefined;
   spotMarketScope?: "all" | "allowlist" | undefined;
-  perpMarketScope?: "all" | "allowlist" | undefined;
-  actions?: ("trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists")[] | undefined;
-  globalLeverageCap?: number | null | undefined;
-  globalExposureCap?: number | null | undefined;
+  actions?: ("trade-spot" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-internal-transfers" | "read-address-book" | "manage-address-book")[] | undefined;
   maxOrderSize?: number | null | undefined;
   maxOpenOrders?: number | null | undefined;
-  maxOpenPositions?: number | null | undefined;
-  dailyInternalTransferLimit?: number | null | undefined;
-  dailyWithdrawLimit?: number | null | undefined;
-  dailyLossLimit?: number | null | undefined;
-  intradayDrawdownLimitPct?: number | null | undefined;
   tradingHalted?: boolean | undefined;
-  liquidationOnly?: boolean | undefined;
   policyLocked?: boolean | undefined;
-  internalTransfersOwnOnly?: boolean | undefined;
-  enforceWithdrawWhitelist?: boolean | undefined;
-  reviewAt?: number | null | undefined;
-  expiresAt?: number | null | undefined;
-}, "Subaccount policy actions must include read-balances and read-spot">, v.CheckAction<{
-  policyId: bigint;
-  expectedRevision: bigint;
-  name?: string | undefined;
-  description?: string | undefined;
-  spotMarkets?: {
-    symbol: string;
-  }[] | undefined;
-  perpMarkets?: {
-    symbol: string;
-    maxLeverageX: number;
-  }[] | undefined;
-  spotMarketScope?: "all" | "allowlist" | undefined;
-  perpMarketScope?: "all" | "allowlist" | undefined;
-  actions?: ("trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists")[] | undefined;
-  globalLeverageCap?: number | null | undefined;
-  globalExposureCap?: number | null | undefined;
-  maxOrderSize?: number | null | undefined;
-  maxOpenOrders?: number | null | undefined;
-  maxOpenPositions?: number | null | undefined;
-  dailyInternalTransferLimit?: number | null | undefined;
-  dailyWithdrawLimit?: number | null | undefined;
-  dailyLossLimit?: number | null | undefined;
-  intradayDrawdownLimitPct?: number | null | undefined;
-  tradingHalted?: boolean | undefined;
-  liquidationOnly?: boolean | undefined;
-  policyLocked?: boolean | undefined;
-  internalTransfersOwnOnly?: boolean | undefined;
-  enforceWithdrawWhitelist?: boolean | undefined;
   reviewAt?: number | null | undefined;
   expiresAt?: number | null | undefined;
 }, "At least one subaccount policy field must be provided">, v.TransformAction<{
@@ -387,27 +206,12 @@ declare const UpdateSubaccountPolicyInputSchema: v.SchemaWithPipe<readonly [v.St
   spotMarkets?: {
     symbol: string;
   }[] | undefined;
-  perpMarkets?: {
-    symbol: string;
-    maxLeverageX: number;
-  }[] | undefined;
   spotMarketScope?: "all" | "allowlist" | undefined;
-  perpMarketScope?: "all" | "allowlist" | undefined;
-  actions?: ("trade-spot" | "trade-perp" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-perp" | "read-internal-transfers" | "read-external-withdrawals" | "read-transfer-controls" | "manage-address-book" | "manage-transfer-whitelists")[] | undefined;
-  globalLeverageCap?: number | null | undefined;
-  globalExposureCap?: number | null | undefined;
+  actions?: ("trade-spot" | "internal-transfer" | "external-withdraw" | "read-balances" | "read-spot" | "read-internal-transfers" | "read-address-book" | "manage-address-book")[] | undefined;
   maxOrderSize?: number | null | undefined;
   maxOpenOrders?: number | null | undefined;
-  maxOpenPositions?: number | null | undefined;
-  dailyInternalTransferLimit?: number | null | undefined;
-  dailyWithdrawLimit?: number | null | undefined;
-  dailyLossLimit?: number | null | undefined;
-  intradayDrawdownLimitPct?: number | null | undefined;
   tradingHalted?: boolean | undefined;
-  liquidationOnly?: boolean | undefined;
   policyLocked?: boolean | undefined;
-  internalTransfersOwnOnly?: boolean | undefined;
-  enforceWithdrawWhitelist?: boolean | undefined;
   reviewAt?: number | null | undefined;
   expiresAt?: number | null | undefined;
 }, {

package/dist/services/policies/subaccount-policies/subaccount-policies.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subaccount-policies.schemas.d.ts","names":[],"sources":["../../../../src/services/policies/subaccount-policies/subaccount-policies.schemas.ts"],"mappings":";;;;cAwCa,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;cASjC,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;cAgB9B,wBAAsB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6EvB,mBAAmB,EAAE,mBAAmB;cA0EvC,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAalC,8BAA8B,EAAE,kBAAkB;cA6HjD,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+BlC,8BAA8B,EAAE,kBAAkB;cASjD,kCAAgC,EAAA;;;;KAQjC,6BAA6B,EAAE,kBAAkB"}
+{"version":3,"file":"subaccount-policies.schemas.d.ts","names":[],"sources":["../../../../src/services/policies/subaccount-policies/subaccount-policies.schemas.ts"],"mappings":";;;;cAqCa,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;cASjC,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;cAgB9B,wBAAsB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqCvB,mBAAmB,EAAE,mBAAmB;cAmDvC,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOlC,8BAA8B,EAAE,kBAAkB;cA6DjD,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BlC,8BAA8B,EAAE,kBAAkB;cASjD,kCAAgC,EAAA;;;;KAQjC,6BAA6B,EAAE,kBAAkB"}

package/dist/services/policies/subaccount-policies/subaccount-policies.schemas.js

@@ -1,8 +1,8 @@
 import { idToBigInt } from "../../../utils/base58-id.js";
-import { bpsToPct, toBigIntOrZero, toBpsOrZero, toIntOrZero } from "../../../utils/numbers.js";
+import { toBigIntOrZero, toIntOrZero } from "../../../utils/numbers.js";
 import { tsObjToMs, tsObjToNsString } from "../../../utils/time.js";
-import { BigIntStringSchema, OptionalNumberToBigIntOrZeroSchema, OptionalNumberToBpsOrZeroSchema, OptionalNumberToIntOrZeroSchema, OptionalPublicIdSchema, OptionalTimestampMsSchema, PublicIdSchema, TimestampMsSchema, TimestampSchema, idInputSchema, optionalSubaccountIdInputSchema, positiveBigintStringInputSchema } from "../../../shared/schemas.js";
-import { PerpMarketRuleSchema, PolicyActionEnumSchema, PolicyMarketScopeEnumSchema, ProtoPolicyActionEnumSchema, ProtoPolicyMarketScopeEnumSchema, SpotMarketRuleSchema } from "../shared.js";
+import { BigIntStringSchema, OptionalNumberToBigIntOrZeroSchema, OptionalNumberToIntOrZeroSchema, OptionalPublicIdSchema, OptionalTimestampMsSchema, PublicIdSchema, TimestampMsSchema, TimestampSchema, idInputSchema, optionalSubaccountIdInputSchema, positiveBigintStringInputSchema } from "../../../shared/schemas.js";
+import { PolicyActionEnumSchema, PolicyMarketScopeEnumSchema, ProtoPolicyActionEnumSchema, ProtoPolicyMarketScopeEnumSchema, SpotMarketRuleSchema } from "../shared.js";
 import { PolicyActionCodec, PolicyMarketScopeCodec, policyActionLabelFor, policyMarketScopeLabelFor } from "../shared.codecs.js";
 import { buildProtoPatch, defineProtoPatchFields } from "../../../utils/proto-patch.js";
 import { toTimestamp } from "../../../utils/timestamp.js";
@@ -26,34 +26,20 @@ const SubaccountPolicySchema = v.pipe(v.object({
 	description: v.string(),
 	spotMarkets: v.optional(v.array(SpotMarketRuleSchema), []),
 	spotMarketScope: v.pipe(ProtoPolicyMarketScopeEnumSchema, v.transform((v) => policyMarketScopeLabelFor(v))),
-	perpMarketScope: v.pipe(ProtoPolicyMarketScopeEnumSchema, v.transform((v) => policyMarketScopeLabelFor(v))),
-	perpMarkets: v.optional(v.array(PerpMarketRuleSchema), []),
 	actions: v.pipe(v.optional(v.array(ProtoPolicyActionEnumSchema), []), v.transform((v) => v.map((action) => policyActionLabelFor(action)))),
 	isTemplate: v.optional(v.boolean(), false),
 	sourceTemplateId: OptionalPublicIdSchema,
-	globalNotionalCap: v.pipe(v.bigint(), v.transform((v) => Number(v))),
 	maxOrderNotional: v.pipe(v.bigint(), v.transform((v) => Number(v))),
 	maxOpenOrders: v.number(),
-	maxOpenPositions: v.number(),
-	globalPerpLeverageX: v.number(),
-	dailyInternalTransferOutLimit: v.pipe(v.bigint(), v.transform((v) => Number(v))),
-	dailyWithdrawLimit: v.pipe(v.bigint(), v.transform((v) => Number(v))),
-	internalTransfersOwnOnly: v.boolean(),
-	enforceWithdrawWhitelist: v.boolean(),
 	tradingHalted: v.boolean(),
-	liquidationOnly: v.boolean(),
-	dailyLossLimit: v.pipe(v.bigint(), v.transform((v) => Number(v))),
-	intradayDrawdownLimitBps: v.pipe(v.number(), v.transform((v) => bpsToPct(v))),
 	locked: v.boolean(),
 	reviewAt: OptionalTimestampMsSchema,
 	expiresAt: OptionalTimestampMsSchema,
 	createdAt: TimestampMsSchema,
 	updatedAt: TimestampSchema,
 	revision: BigIntStringSchema
-}), v.transform(({ maxOrderNotional, globalNotionalCap, intradayDrawdownLimitBps, updatedAt, ...rest }) => ({
+}), v.transform(({ maxOrderNotional, updatedAt, ...rest }) => ({
 	maxOrderSize: maxOrderNotional,
-	globalExposureCap: globalNotionalCap,
-	intradayDrawdownLimitPct: intradayDrawdownLimitBps,
 	...rest,
 	updatedAt: tsObjToMs(updatedAt),
 	updatedAtNs: tsObjToNsString(updatedAt)
@@ -62,24 +48,12 @@ const SubaccountPolicyInputBaseSchema = v.strictObject({
 	name: v.string(),
 	description: v.optional(v.string(), ""),
 	spotMarkets: v.optional(v.array(SpotMarketRuleSchema), []),
-	perpMarkets: v.optional(v.array(PerpMarketRuleSchema), []),
 	spotMarketScope: v.pipe(PolicyMarketScopeEnumSchema, v.transform((v) => PolicyMarketScopeCodec.inputToProto[v])),
-	perpMarketScope: v.pipe(PolicyMarketScopeEnumSchema, v.transform((v) => PolicyMarketScopeCodec.inputToProto[v])),
-	actions: v.pipe(v.optional(v.array(PolicyActionEnumSchema), ["read-balances", "read-spot"]), v.transform((v) => (v ?? []).map((action) => PolicyActionCodec.inputToProto[action]))),
-	globalLeverageCap: OptionalNumberToIntOrZeroSchema,
-	globalExposureCap: OptionalNumberToBigIntOrZeroSchema,
+	actions: v.pipe(v.optional(v.array(PolicyActionEnumSchema), []), v.transform((v) => (v ?? []).map((action) => PolicyActionCodec.inputToProto[action]))),
 	maxOrderSize: OptionalNumberToBigIntOrZeroSchema,
 	maxOpenOrders: OptionalNumberToIntOrZeroSchema,
-	maxOpenPositions: OptionalNumberToIntOrZeroSchema,
-	dailyInternalTransferLimit: OptionalNumberToBigIntOrZeroSchema,
-	dailyWithdrawLimit: OptionalNumberToBigIntOrZeroSchema,
-	dailyLossLimit: OptionalNumberToBigIntOrZeroSchema,
-	intradayDrawdownLimitPct: OptionalNumberToBpsOrZeroSchema,
 	tradingHalted: v.optional(v.boolean(), false),
-	liquidationOnly: v.optional(v.boolean(), false),
 	policyLocked: v.optional(v.boolean(), false),
-	internalTransfersOwnOnly: v.optional(v.boolean(), true),
-	enforceWithdrawWhitelist: v.optional(v.boolean(), false),
 	reviewAt: v.optional(v.nullable(v.pipe(v.number(), v.integer(), v.minValue(0)))),
 	expiresAt: v.optional(v.nullable(v.pipe(v.number(), v.integer(), v.minValue(0)))),
 	subaccountId: optionalSubaccountIdInputSchema()
@@ -92,20 +66,16 @@ function timestampFromMs(value) {
 	});
 }
 function createSubaccountPolicyBaseTransform(input) {
-	const { subaccountId: _subaccountId, reviewAt, expiresAt, globalExposureCap, maxOrderSize, globalLeverageCap, dailyInternalTransferLimit, intradayDrawdownLimitPct, policyLocked, ...rest } = input;
+	const { subaccountId: _subaccountId, reviewAt, expiresAt, maxOrderSize, policyLocked, ...rest } = input;
 	return {
 		...rest,
-		globalNotionalCap: globalExposureCap,
 		maxOrderNotional: maxOrderSize,
-		globalPerpLeverageX: globalLeverageCap,
-		dailyInternalTransferOutLimit: dailyInternalTransferLimit,
-		intradayDrawdownLimitBps: intradayDrawdownLimitPct,
 		locked: policyLocked,
 		reviewAt: timestampFromMs(reviewAt),
 		expiresAt: timestampFromMs(expiresAt)
 	};
 }
-const CreateSubaccountPolicyInputSchema = v.pipe(SubaccountPolicyInputBaseSchema, v.check(({ actions }) => actions.includes(PolicyActionCodec.inputToProto["read-balances"]) && actions.includes(PolicyActionCodec.inputToProto["read-spot"]), "Subaccount policy actions must include read-balances and read-spot"), v.transform((input) => ({
+const CreateSubaccountPolicyInputSchema = v.pipe(SubaccountPolicyInputBaseSchema, v.transform((input) => ({
 	policy: createSubaccountPolicyBaseTransform(input),
 	subaccountId: input.subaccountId
 })));
@@ -113,24 +83,12 @@ const SubaccountPolicyPatchSchema = v.strictObject({
 	name: v.optional(v.string()),
 	description: v.optional(v.string()),
 	spotMarkets: v.optional(v.array(SpotMarketRuleSchema)),
-	perpMarkets: v.optional(v.array(PerpMarketRuleSchema)),
 	spotMarketScope: v.optional(PolicyMarketScopeEnumSchema),
-	perpMarketScope: v.optional(PolicyMarketScopeEnumSchema),
 	actions: v.optional(v.array(PolicyActionEnumSchema)),
-	globalLeverageCap: v.optional(v.nullable(v.number())),
-	globalExposureCap: v.optional(v.nullable(v.number())),
 	maxOrderSize: v.optional(v.nullable(v.number())),
 	maxOpenOrders: v.optional(v.nullable(v.number())),
-	maxOpenPositions: v.optional(v.nullable(v.number())),
-	dailyInternalTransferLimit: v.optional(v.nullable(v.number())),
-	dailyWithdrawLimit: v.optional(v.nullable(v.number())),
-	dailyLossLimit: v.optional(v.nullable(v.number())),
-	intradayDrawdownLimitPct: v.optional(v.nullable(v.number())),
 	tradingHalted: v.optional(v.boolean()),
-	liquidationOnly: v.optional(v.boolean()),
 	policyLocked: v.optional(v.boolean()),
-	internalTransfersOwnOnly: v.optional(v.boolean()),
-	enforceWithdrawWhitelist: v.optional(v.boolean()),
 	reviewAt: v.optional(v.nullable(v.pipe(v.number(), v.integer(), v.minValue(0)))),
 	expiresAt: v.optional(v.nullable(v.pipe(v.number(), v.integer(), v.minValue(0))))
 });
@@ -147,26 +105,14 @@ const SUBACCOUNT_POLICY_PATCH_FIELDS = defineProtoPatchFields()({
 		path: "spot_markets",
 		encode: (spotMarkets) => ({ spotMarkets })
 	},
-	perpMarkets: {
-		path: "perp_markets",
-		encode: (perpMarkets) => ({ perpMarkets })
-	},
 	spotMarketScope: {
 		path: "spot_market_scope",
 		encode: (scope) => ({ spotMarketScope: PolicyMarketScopeCodec.inputToProto[scope] })
 	},
-	perpMarketScope: {
-		path: "perp_market_scope",
-		encode: (scope) => ({ perpMarketScope: PolicyMarketScopeCodec.inputToProto[scope] })
-	},
 	actions: {
 		path: "actions",
 		encode: (actions) => ({ actions: actions.map((action) => PolicyActionCodec.inputToProto[action]) })
 	},
-	globalExposureCap: {
-		path: "global_notional_cap",
-		encode: (value) => ({ globalNotionalCap: toBigIntOrZero(value) })
-	},
 	maxOrderSize: {
 		path: "max_order_notional",
 		encode: (value) => ({ maxOrderNotional: toBigIntOrZero(value) })
@@ -175,46 +121,10 @@ const SUBACCOUNT_POLICY_PATCH_FIELDS = defineProtoPatchFields()({
 		path: "max_open_orders",
 		encode: (value) => ({ maxOpenOrders: toIntOrZero(value) })
 	},
-	maxOpenPositions: {
-		path: "max_open_positions",
-		encode: (value) => ({ maxOpenPositions: toIntOrZero(value) })
-	},
-	globalLeverageCap: {
-		path: "global_perp_leverage_x",
-		encode: (value) => ({ globalPerpLeverageX: toIntOrZero(value) })
-	},
-	dailyInternalTransferLimit: {
-		path: "daily_internal_transfer_out_limit",
-		encode: (value) => ({ dailyInternalTransferOutLimit: toBigIntOrZero(value) })
-	},
-	dailyWithdrawLimit: {
-		path: "daily_withdraw_limit",
-		encode: (value) => ({ dailyWithdrawLimit: toBigIntOrZero(value) })
-	},
-	internalTransfersOwnOnly: {
-		path: "internal_transfers_own_only",
-		encode: (internalTransfersOwnOnly) => ({ internalTransfersOwnOnly })
-	},
-	enforceWithdrawWhitelist: {
-		path: "enforce_withdraw_whitelist",
-		encode: (enforceWithdrawWhitelist) => ({ enforceWithdrawWhitelist })
-	},
 	tradingHalted: {
 		path: "trading_halted",
 		encode: (tradingHalted) => ({ tradingHalted })
 	},
-	liquidationOnly: {
-		path: "liquidation_only",
-		encode: (liquidationOnly) => ({ liquidationOnly })
-	},
-	dailyLossLimit: {
-		path: "daily_loss_limit",
-		encode: (value) => ({ dailyLossLimit: toBigIntOrZero(value) })
-	},
-	intradayDrawdownLimitPct: {
-		path: "intraday_drawdown_limit_bps",
-		encode: (value) => ({ intradayDrawdownLimitBps: toBpsOrZero(value) })
-	},
 	policyLocked: {
 		path: "locked",
 		encode: (locked) => ({ locked })
@@ -234,14 +144,11 @@ const SUBACCOUNT_POLICY_PATCH_FIELDS = defineProtoPatchFields()({
 		}
 	}
 });
-function hasMandatorySubaccountActions(actions) {
-	return actions === void 0 || actions.includes("read-balances") && actions.includes("read-spot");
-}
 const UpdateSubaccountPolicyInputSchema = v.pipe(v.strictObject({
 	...SubaccountPolicyPatchSchema.entries,
 	policyId: v.pipe(v.string(), v.transform((v) => idToBigInt(v, "policyId"))),
 	expectedRevision: positiveBigintStringInputSchema("expectedRevision")
-}), v.check(({ actions }) => hasMandatorySubaccountActions(actions), "Subaccount policy actions must include read-balances and read-spot"), v.check(({ policyId: _policyId, expectedRevision: _expectedRevision, ...patch }) => Object.values(patch).some((value) => value !== void 0), "At least one subaccount policy field must be provided"), v.transform(({ policyId, expectedRevision, ...patch }) => {
+}), v.check(({ policyId: _policyId, expectedRevision: _expectedRevision, ...patch }) => Object.values(patch).some((value) => value !== void 0), "At least one subaccount policy field must be provided"), v.transform(({ policyId, expectedRevision, ...patch }) => {
 	const { patch: policy, updateMask } = buildProtoPatch(patch, SUBACCOUNT_POLICY_PATCH_FIELDS);
 	return {
 		policyId,
@@ -261,28 +168,16 @@ const DEFAULT_SUBACCOUNT_POLICY = {
 	name: "Subaccount Policy",
 	description: "Subaccount Policy description",
 	spotMarkets: [],
-	perpMarkets: [],
 	spotMarketScope: "all",
-	perpMarketScope: "all",
 	actions: [
 		"read-balances",
-		"read-external-withdrawals",
 		"read-internal-transfers",
-		"read-perp",
+		"read-address-book",
 		"read-spot"
 	],
-	globalExposureCap: 0,
 	maxOrderSize: 0,
 	maxOpenOrders: 0,
-	maxOpenPositions: 0,
-	globalPerpLeverageX: 0,
-	dailyInternalTransferOutLimit: 0,
-	dailyWithdrawLimit: 0,
-	internalTransfersOwnOnly: true,
-	enforceWithdrawWhitelist: false,
 	tradingHalted: false,
-	liquidationOnly: false,
-	dailyLossLimit: 0,
 	createdAt: DEFAULT_SUBACCOUNT_POLICY_UPDATED_AT,
 	updatedAt: DEFAULT_SUBACCOUNT_POLICY_UPDATED_AT,
 	updatedAtNs: (BigInt(DEFAULT_SUBACCOUNT_POLICY_UPDATED_AT) * 1000000n).toString(),
@@ -291,7 +186,6 @@ const DEFAULT_SUBACCOUNT_POLICY = {
 	locked: false,
 	reviewAt: void 0,
 	expiresAt: void 0,
-	intradayDrawdownLimitPct: 0,
 	revision: "0"
 };
 //#endregion