@pear-protocol/types 1.14.1 → 1.15.0

package/dist/market/queries.d.ts

@@ -8,10 +8,10 @@ export declare const MarketsQueryParams: z.ZodObject<{
         lighter: "lighter";
     }>;
     scope: z.ZodDefault<z.ZodEnum<{
-        all: "all";
         tradable: "tradable";
         reduce_only: "reduce_only";
         not_tradable: "not_tradable";
+        all: "all";
     }>>;
 }, z.core.$strip>;
 export type MarketsQueryParamsInput = z.input<typeof MarketsQueryParams>;
@@ -25,10 +25,10 @@ export declare const MarketBasketsQueryParams: z.ZodObject<{
         lighter: "lighter";
     }>;
     scope: z.ZodDefault<z.ZodEnum<{
-        all: "all";
         tradable: "tradable";
         reduce_only: "reduce_only";
         not_tradable: "not_tradable";
+        all: "all";
     }>>;
     search: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;

package/dist/notification/queries.d.ts

@@ -4,8 +4,8 @@ export declare const NotificationListParams: z.ZodObject<{
     startDate: z.ZodOptional<z.ZodCoercedDate<Date>>;
     endDate: z.ZodOptional<z.ZodCoercedDate<Date>>;
     scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        all: "all";
         read: "read";
+        all: "all";
         unread: "unread";
     }>>>;
 }, z.core.$strip>;

package/dist/order/entities.d.ts

@@ -33,7 +33,6 @@ export declare const MarketOrder: z.ZodObject<{
         SELL: "SELL";
     }>;
     reduceOnly: z.ZodBoolean;
-    leverage: z.ZodInt;
     quantity: z.ZodString;
     price: z.ZodString;
     filledQuantity: z.ZodString;
@@ -65,7 +64,6 @@ export declare const Order: z.ZodDiscriminatedUnion<[z.ZodObject<{
         SELL: "SELL";
     }>;
     reduceOnly: z.ZodBoolean;
-    leverage: z.ZodInt;
     quantity: z.ZodString;
     price: z.ZodString;
     filledQuantity: z.ZodString;

package/dist/order/entities.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { UnsignedDecimalString, Leverage, Side } from '../common/schema';
+import { UnsignedDecimalString, Side } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
 
@@ -47,10 +47,6 @@ const MarketOrder = BaseOrder.extend({
    * Reduce only flag
    */
   reduceOnly: z.boolean(),
-  /**
-   * Leverage
-   */
-  leverage: Leverage,
   /**
    * Contract quantity to trade
    */

package/dist/portfolio/entities.d.ts

@@ -178,6 +178,9 @@ export declare const PortfolioSeriesPoint: z.ZodObject<{
     wins: z.ZodNumber;
     losses: z.ZodNumber;
     dayPnl: z.ZodNumber;
+    dayVolume: z.ZodNumber;
+    dayFunding: z.ZodNumber;
+    dayNetPnl: z.ZodNumber;
     hitRate: z.ZodNullable<z.ZodNumber>;
     winLossRatio: z.ZodNullable<z.ZodNumber>;
     rollingHitRate: z.ZodNullable<z.ZodNumber>;
@@ -195,5 +198,6 @@ export declare const PortfolioAnalyticsConfig: z.ZodObject<{
     rollingWindowDays: z.ZodNumber;
     startDate: z.ZodString;
     endDate: z.ZodString;
+    fundingSynced: z.ZodBoolean;
 }, z.core.$strip>;
 export type PortfolioAnalyticsConfig = z.output<typeof PortfolioAnalyticsConfig>;

package/dist/portfolio/entities.js

@@ -79,6 +79,12 @@ const PortfolioSeriesPoint = z.object({
   wins: z.number(),
   losses: z.number(),
   dayPnl: z.number(),
+  // Fill notional traded that UTC day; honours the query's `source` filter.
+  dayVolume: z.number(),
+  // Account-level funding accrued that UTC day (signed; negative when the trader paid).
+  dayFunding: z.number(),
+  // dayPnl plus dayFunding — the figure that reconciles with the trader's exchange statement.
+  dayNetPnl: z.number(),
   hitRate: NullableNumber,
   winLossRatio: NullableNumber,
   rollingHitRate: NullableNumber,
@@ -94,7 +100,10 @@ const PortfolioSeriesPoint = z.object({
 const PortfolioAnalyticsConfig = z.object({
   rollingWindowDays: z.number(),
   startDate: z.string(),
-  endDate: z.string()
+  endDate: z.string(),
+  // Whether funding history has ever reached the backend for this account. When false, every
+  // `dayFunding` is unknown rather than zero. Carries no claim about how recent the sync was.
+  fundingSynced: z.boolean()
 });
 
 export { NullableNumber, PortfolioAnalyticsConfig, PortfolioAssetAnalytics, PortfolioIntervalBucket, PortfolioIntervals, PortfolioMetricVariant, PortfolioMetrics, PortfolioOverall, PortfolioPairBreakdown, PortfolioSeriesPoint };

package/dist/portfolio/responses.d.ts

@@ -71,6 +71,7 @@ export declare const PortfolioAnalyticsResponse: z.ZodObject<{
         rollingWindowDays: z.ZodNumber;
         startDate: z.ZodString;
         endDate: z.ZodString;
+        fundingSynced: z.ZodBoolean;
     }, z.core.$strip>;
     portfolio: z.ZodObject<{
         realizedOnly: z.ZodObject<{
@@ -156,6 +157,9 @@ export declare const PortfolioAnalyticsResponse: z.ZodObject<{
         wins: z.ZodNumber;
         losses: z.ZodNumber;
         dayPnl: z.ZodNumber;
+        dayVolume: z.ZodNumber;
+        dayFunding: z.ZodNumber;
+        dayNetPnl: z.ZodNumber;
         hitRate: z.ZodNullable<z.ZodNumber>;
         winLossRatio: z.ZodNullable<z.ZodNumber>;
         rollingHitRate: z.ZodNullable<z.ZodNumber>;

package/dist/schedule/entities.d.ts

@@ -20,11 +20,6 @@ export declare const ScheduleExecutionType: z.ZodEnum<{
     MARKET: "MARKET";
 }>;
 export type ScheduleExecutionType = z.infer<typeof ScheduleExecutionType>;
-export declare const ScheduleSliceMode: z.ZodEnum<{
-    QUANTITY: "QUANTITY";
-    USD: "USD";
-}>;
-export type ScheduleSliceMode = z.infer<typeof ScheduleSliceMode>;
 export declare const ScheduleCancelledReason: z.ZodEnum<{
     USER: "USER";
     POSITION_CLOSED: "POSITION_CLOSED";
@@ -33,21 +28,13 @@ export declare const ScheduleCancelledReason: z.ZodEnum<{
     POSITION_REVERSED: "POSITION_REVERSED";
 }>;
 export type ScheduleCancelledReason = z.infer<typeof ScheduleCancelledReason>;
-declare const TWAPSliceOpenLeg: z.ZodObject<{
+declare const TWAPOpenLeg: z.ZodObject<{
     symbol: z.ZodString;
     side: z.ZodEnum<{
         BUY: "BUY";
         SELL: "SELL";
     }>;
-    mode: z.ZodEnum<{
-        QUANTITY: "QUANTITY";
-        USD: "USD";
-    }>;
-    stepAmount: z.ZodString;
-}, z.core.$strip>;
-declare const TWAPSliceCloseLeg: z.ZodObject<{
-    symbol: z.ZodString;
-    stepAmount: z.ZodString;
+    weight: z.ZodNumber;
 }, z.core.$strip>;
 declare const BaseSchedule: z.ZodObject<{
     id: z.ZodUUID;
@@ -199,17 +186,18 @@ export declare const TWAPOpen: z.ZodObject<{
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"OPEN">;
     sliceIntervalSec: z.ZodNumber;
-    sliceLegs: z.ZodArray<z.ZodObject<{
+    sliceCount: z.ZodNumber;
+    randomization: z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>;
+    legs: z.ZodArray<z.ZodObject<{
         symbol: z.ZodString;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        mode: z.ZodEnum<{
-            QUANTITY: "QUANTITY";
-            USD: "USD";
-        }>;
-        stepAmount: z.ZodString;
+        weight: z.ZodNumber;
     }, z.core.$strip>>;
     targetNotional: z.ZodString;
     remainingNotional: z.ZodString;
@@ -286,11 +274,12 @@ export declare const TWAPClose: z.ZodObject<{
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"CLOSE">;
     sliceIntervalSec: z.ZodNumber;
+    sliceCount: z.ZodNumber;
+    randomization: z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>;
     positionId: z.ZodUUID;
-    sliceLegs: z.ZodArray<z.ZodObject<{
-        symbol: z.ZodString;
-        stepAmount: z.ZodString;
-    }, z.core.$strip>>;
     initialExposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
 }, z.core.$strip>;
 export declare const Schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -365,17 +354,18 @@ export declare const Schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"OPEN">;
     sliceIntervalSec: z.ZodNumber;
-    sliceLegs: z.ZodArray<z.ZodObject<{
+    sliceCount: z.ZodNumber;
+    randomization: z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>;
+    legs: z.ZodArray<z.ZodObject<{
         symbol: z.ZodString;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        mode: z.ZodEnum<{
-            QUANTITY: "QUANTITY";
-            USD: "USD";
-        }>;
-        stepAmount: z.ZodString;
+        weight: z.ZodNumber;
     }, z.core.$strip>>;
     targetNotional: z.ZodString;
     remainingNotional: z.ZodString;
@@ -451,15 +441,15 @@ export declare const Schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"CLOSE">;
     sliceIntervalSec: z.ZodNumber;
+    sliceCount: z.ZodNumber;
+    randomization: z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>;
     positionId: z.ZodUUID;
-    sliceLegs: z.ZodArray<z.ZodObject<{
-        symbol: z.ZodString;
-        stepAmount: z.ZodString;
-    }, z.core.$strip>>;
     initialExposure: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>>;
 }, z.core.$strip>], "intent">;
-export type TWAPSliceOpenLeg = z.output<typeof TWAPSliceOpenLeg>;
-export type TWAPSliceCloseLeg = z.output<typeof TWAPSliceCloseLeg>;
+export type TWAPOpenLeg = z.output<typeof TWAPOpenLeg>;
 export type BaseSchedule = z.output<typeof BaseSchedule>;
 export type TWAPOpen = z.output<typeof TWAPOpen>;
 export type TWAPClose = z.output<typeof TWAPClose>;

package/dist/schedule/entities.js

@@ -1,14 +1,14 @@
 import { z } from 'zod';
-import { UnsignedDecimalString, Side, SignedDecimalString } from '../common/schema';
+import { AssetWeight, Side, UnsignedDecimalString, SignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { Fill } from '../fill/entities';
 import { InstrumentId } from '../instrument';
+import { TWAPRandomization } from './randomization';
 
 const ScheduleStrategy = z.enum(["TWAP", "VWAP"]);
 const ScheduleStatus = z.enum(["ACTIVE", "COMPLETED", "FAILED", "CANCELLED"]);
 const ScheduleIntent = z.enum(["OPEN", "CLOSE"]);
 const ScheduleExecutionType = z.enum(["MARKET"]);
-const ScheduleSliceMode = z.enum(["QUANTITY", "USD"]);
 const ScheduleCancelledReason = z.enum([
   "POSITION_CLOSED",
   "USER",
@@ -16,7 +16,7 @@ const ScheduleCancelledReason = z.enum([
   "POSITION_NETTED",
   "POSITION_REVERSED"
 ]);
-const TWAPSliceOpenLeg = z.object({
+const TWAPOpenLeg = z.object({
   /**
    * Instrument ID
    */
@@ -26,25 +26,9 @@ const TWAPSliceOpenLeg = z.object({
    */
   side: Side,
   /**
-   * Mode to interpret the step amount
-   * @example QUANTITY: 0.001 means 0.001 BTC units
-   * @example USD: 100 means $100 USD
+   * Share of the parent target notional allocated to this leg
    */
-  mode: ScheduleSliceMode,
-  /**
-   * Step amount
-   */
-  stepAmount: UnsignedDecimalString
-});
-const TWAPSliceCloseLeg = z.object({
-  /**
-   * Instrument ID
-   */
-  symbol: InstrumentId,
-  /**
-   * Step amount
-   */
-  stepAmount: UnsignedDecimalString
+  weight: AssetWeight
 });
 const BaseSchedule = z.object({
   /**
@@ -122,9 +106,17 @@ const TWAPOpen = BaseSchedule.extend({
    */
   sliceIntervalSec: z.number(),
   /**
-   * Slice legs
+   * Number of slices planned inside the execution window
    */
-  sliceLegs: z.array(TWAPSliceOpenLeg),
+  sliceCount: z.number().int().positive(),
+  /**
+   * Bounded timing and basket-size randomization
+   */
+  randomization: TWAPRandomization,
+  /**
+   * Parent-order leg allocation
+   */
+  legs: z.array(TWAPOpenLeg),
   /**
    * Target notional
    */
@@ -148,13 +140,17 @@ const TWAPClose = BaseSchedule.extend({
    */
   sliceIntervalSec: z.number(),
   /**
-   * Position UUID
+   * Number of slices planned inside the execution window
    */
-  positionId: z.uuid(),
+  sliceCount: z.number().int().positive(),
   /**
-   * Slice legs
+   * Bounded timing and basket-size randomization
    */
-  sliceLegs: z.array(TWAPSliceCloseLeg),
+  randomization: TWAPRandomization,
+  /**
+   * Position UUID
+   */
+  positionId: z.uuid(),
   /**
    * Initial exposure
    */
@@ -162,4 +158,4 @@ const TWAPClose = BaseSchedule.extend({
 });
 const Schedule = z.discriminatedUnion("intent", [TWAPOpen, TWAPClose]);
 
-export { Schedule, ScheduleCancelledReason, ScheduleExecutionType, ScheduleIntent, ScheduleSliceMode, ScheduleStatus, ScheduleStrategy, TWAPClose, TWAPOpen };
+export { Schedule, ScheduleCancelledReason, ScheduleExecutionType, ScheduleIntent, ScheduleStatus, ScheduleStrategy, TWAPClose, TWAPOpen };

package/dist/schedule/index.d.ts

@@ -1,4 +1,5 @@
 export * from './entities';
 export * from './payloads';
 export * from './queries';
+export * from './randomization';
 export * from './responses';

package/dist/schedule/index.js

@@ -1,4 +1,5 @@
 export * from './entities';
 export * from './payloads';
 export * from './queries';
+export * from './randomization';
 export * from './responses';

package/dist/schedule/payloads.d.ts

@@ -1,71 +1,71 @@
 import { z } from 'zod';
 export declare const CreateTWAPOpen: z.ZodObject<{
-    startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
-    endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
+    startAt: z.ZodCoercedDate<unknown>;
+    endAt: z.ZodCoercedDate<unknown>;
+    randomization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>>>;
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"OPEN">;
     executionType: z.ZodLiteral<"MARKET">;
-    sliceLegs: z.ZodArray<z.ZodObject<{
+    legs: z.ZodArray<z.ZodObject<{
         symbol: z.ZodString;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        mode: z.ZodEnum<{
-            QUANTITY: "QUANTITY";
-            USD: "USD";
-        }>;
-        stepAmount: z.ZodString;
+        weight: z.ZodNumber;
     }, z.core.$strip>>;
     targetNotional: z.ZodString;
     sliceIntervalSec: z.ZodInt;
     clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const CreateTWAPClose: z.ZodObject<{
-    startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
-    endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
+    startAt: z.ZodCoercedDate<unknown>;
+    endAt: z.ZodCoercedDate<unknown>;
+    randomization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>>>;
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"CLOSE">;
     executionType: z.ZodLiteral<"MARKET">;
-    sliceLegs: z.ZodArray<z.ZodObject<{
-        symbol: z.ZodString;
-        stepAmount: z.ZodString;
-    }, z.core.$strip>>;
     positionId: z.ZodUUID;
     sliceIntervalSec: z.ZodInt;
     clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const CreateSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
-    endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
+    startAt: z.ZodCoercedDate<unknown>;
+    endAt: z.ZodCoercedDate<unknown>;
+    randomization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>>>;
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"OPEN">;
     executionType: z.ZodLiteral<"MARKET">;
-    sliceLegs: z.ZodArray<z.ZodObject<{
+    legs: z.ZodArray<z.ZodObject<{
         symbol: z.ZodString;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        mode: z.ZodEnum<{
-            QUANTITY: "QUANTITY";
-            USD: "USD";
-        }>;
-        stepAmount: z.ZodString;
+        weight: z.ZodNumber;
     }, z.core.$strip>>;
     targetNotional: z.ZodString;
     sliceIntervalSec: z.ZodInt;
     clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
-    startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
-    endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
+    startAt: z.ZodCoercedDate<unknown>;
+    endAt: z.ZodCoercedDate<unknown>;
+    randomization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        timingJitterBps: z.ZodInt;
+        sizeJitterBps: z.ZodInt;
+    }, z.core.$strip>>>;
     strategy: z.ZodLiteral<"TWAP">;
     intent: z.ZodLiteral<"CLOSE">;
     executionType: z.ZodLiteral<"MARKET">;
-    sliceLegs: z.ZodArray<z.ZodObject<{
-        symbol: z.ZodString;
-        stepAmount: z.ZodString;
-    }, z.core.$strip>>;
     positionId: z.ZodUUID;
     sliceIntervalSec: z.ZodInt;
     clientId: z.ZodOptional<z.ZodString>;

package/dist/schedule/payloads.js

@@ -1,14 +1,17 @@
 import { z } from 'zod';
 import { ClientIdCode } from '../common/client-id';
-import { UnsignedDecimalString, Side } from '../common/schema';
+import { RefineMinimumOneSymbol, RefineUniqueSymbols, RefineWeightingSum } from '../common/refinement';
+import { UnsignedDecimalString, AssetWeight, Side } from '../common/schema';
 import { InstrumentId } from '../instrument';
-import { ScheduleSliceMode } from './entities';
+import { TWAPRandomization, DEFAULT_TWAP_RANDOMIZATION } from './randomization';
 
 const THIRTY_ONE_DAYS_SEC = 60 * 60 * 24 * 31;
-const SliceIntervalSec = z.int().min(15).max(THIRTY_ONE_DAYS_SEC);
-const DefaultStartAt = z.coerce.date().optional().transform((value) => value ?? /* @__PURE__ */ new Date());
-const DefaultEndAt = z.coerce.date().optional().transform((value) => value ?? new Date(Date.now() + THIRTY_ONE_DAYS_SEC * 1e3));
-const TWAPSliceOpenLeg = z.object({
+const MIN_TWAP_WINDOW_SEC = 15;
+const SliceIntervalSec = z.int().min(MIN_TWAP_WINDOW_SEC).max(THIRTY_ONE_DAYS_SEC);
+const TargetNotional = UnsignedDecimalString.refine((value) => /[1-9]/.test(value), {
+  message: "Target notional must be greater than zero"
+});
+const TWAPOpenLeg = z.object({
   /**
    * Instrument ID
    */
@@ -18,37 +21,28 @@ const TWAPSliceOpenLeg = z.object({
    */
   side: Side,
   /**
-   * Mode to interpret the step amount
-   * @example QUANTITY: 0.001 means 0.001 BTC units
-   * @example USD: 100 means $100 USD
-   */
-  mode: ScheduleSliceMode,
-  /**
-   * Step amount for each slice depending on the mode
-   */
-  stepAmount: UnsignedDecimalString
-});
-const TWAPSliceCloseLeg = z.object({
-  /**
-   * Instrument ID
-   */
-  symbol: InstrumentId,
-  /**
-   * Step amount for each slice in base units
+   * Share of the parent target notional allocated to this leg
    */
-  stepAmount: UnsignedDecimalString
+  weight: AssetWeight
 });
+const TWAPOpenLegs = z.array(TWAPOpenLeg).superRefine(RefineMinimumOneSymbol).superRefine(RefineUniqueSymbols).superRefine(RefineWeightingSum);
 const BaseSchedule = z.object({
   /**
    * Start at date
    */
-  startAt: DefaultStartAt,
+  startAt: z.coerce.date(),
   /**
    * End at date
    */
-  endAt: DefaultEndAt
+  endAt: z.coerce.date(),
+  /**
+   * Optional bounded timing and basket-size randomization
+   */
+  randomization: TWAPRandomization.optional().default(DEFAULT_TWAP_RANDOMIZATION)
 }).refine((data) => data.startAt && data.endAt && data.startAt < data.endAt, {
   message: "Start at date must be before end at date"
+}).refine((data) => data.endAt.getTime() - data.startAt.getTime() >= MIN_TWAP_WINDOW_SEC * 1e3, {
+  message: `TWAP execution window must be at least ${MIN_TWAP_WINDOW_SEC} seconds`
 });
 const CreateTWAPOpen = BaseSchedule.safeExtend({
   /**
@@ -64,13 +58,13 @@ const CreateTWAPOpen = BaseSchedule.safeExtend({
    */
   executionType: z.literal("MARKET"),
   /**
-   * Step configuration for each leg
+   * Parent-order allocation for each leg
    */
-  sliceLegs: z.array(TWAPSliceOpenLeg),
+  legs: TWAPOpenLegs,
   /**
    * Target notional
    */
-  targetNotional: UnsignedDecimalString,
+  targetNotional: TargetNotional,
   /**
    * Slice interval in seconds
    */
@@ -93,10 +87,6 @@ const CreateTWAPClose = BaseSchedule.safeExtend({
    * Execution type
    */
   executionType: z.literal("MARKET"),
-  /**
-   * Step configuration for each leg
-   */
-  sliceLegs: z.array(TWAPSliceCloseLeg),
   /**
    * Position UUID
    */

package/dist/schedule/randomization.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const DEFAULT_TWAP_RANDOMIZATION: {
+    readonly timingJitterBps: 0;
+    readonly sizeJitterBps: 0;
+};
+export declare const TWAPRandomization: z.ZodObject<{
+    timingJitterBps: z.ZodInt;
+    sizeJitterBps: z.ZodInt;
+}, z.core.$strip>;
+export type TWAPRandomization = z.output<typeof TWAPRandomization>;

package/dist/schedule/randomization.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+const MAX_JITTER_BPS = 5e3;
+const DEFAULT_TWAP_RANDOMIZATION = {
+  timingJitterBps: 0,
+  sizeJitterBps: 0
+};
+const TWAPRandomization = z.object({
+  /** Maximum symmetric timing variation in basis points, capped at ±50%. */
+  timingJitterBps: z.int().min(0).max(MAX_JITTER_BPS),
+  /** Maximum symmetric basket-size variation in basis points, capped at ±50%. */
+  sizeJitterBps: z.int().min(0).max(MAX_JITTER_BPS)
+});
+
+export { DEFAULT_TWAP_RANDOMIZATION, TWAPRandomization };