@pear-protocol/types 2.21.0 → 2.22.1

package/dist/rebalance/entities.js

@@ -1,86 +0,0 @@
-import { z } from 'zod';
-import { UnsignedDecimalString } from '../common/schema';
-import { InstrumentId } from '../instrument';
-
-const AutoRebalanceStatus = z.enum([
-  "ACTIVE",
-  "PAUSED"
-]);
-const AutoRebalancePausedReason = z.enum([
-  "USER",
-  "POSITION_CHANGED",
-  "REPEATED_FAILURES",
-  "INVALID_LIVE_BETA_EXPOSURE"
-]);
-const AutoRebalanceWeightSource = z.enum([
-  "INITIAL_WEIGHT",
-  "LIVE_BETA"
-]);
-const AutoRebalanceTimeframe = z.enum([
-  "1h",
-  "4h",
-  "1d"
-]);
-const RebalanceEventStatus = z.enum([
-  "SUCCESS",
-  "FAILED"
-]);
-const WeightMap = z.record(InstrumentId, z.number());
-const AutoRebalanceConfigBase = z.object({
-  id: z.uuid(),
-  positionId: z.uuid(),
-  status: AutoRebalanceStatus,
-  pausedReason: AutoRebalancePausedReason.optional(),
-  minimumDriftPct: UnsignedDecimalString,
-  createdAt: z.iso.datetime(),
-  updatedAt: z.iso.datetime()
-});
-const AutoRebalanceBetaState = z.discriminatedUnion("state", [
-  z.object({
-    state: z.literal("PENDING")
-  }),
-  z.object({
-    state: z.literal("BASELINED"),
-    // The frozen drift baseline: implied beta of the achieved leg split at entry, re-snapshotted after
-    // every rebalance.
-    impliedEntryBeta: UnsignedDecimalString
-  }),
-  z.object({
-    state: z.literal("TRACKING"),
-    // The frozen drift baseline: implied beta of the achieved leg split at entry, re-snapshotted after
-    // every rebalance.
-    impliedEntryBeta: UnsignedDecimalString,
-    // Kalman beta of the last candle this config processed — the moving side of the drift comparison.
-    lastDerivedBeta: UnsignedDecimalString,
-    // Bar time lastDerivedBeta was read at, so a client can judge how fresh that beta is.
-    lastProcessedBetaTime: z.iso.datetime(),
-    // How far lastDerivedBeta sits from impliedEntryBeta, as a fraction (0.05 = 5%) directly comparable
-    // to minimumDriftPct. Derived from the two betas above; absent on a degenerate (zero) baseline.
-    driftPct: UnsignedDecimalString.optional()
-  })
-]);
-const AutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  AutoRebalanceConfigBase.extend({
-    weightSource: z.literal("INITIAL_WEIGHT")
-  }),
-  AutoRebalanceConfigBase.extend({
-    weightSource: z.literal("LIVE_BETA"),
-    // Stat-arb bar timeframe selecting which realtime candle feed drives the drift comparison.
-    timeframe: AutoRebalanceTimeframe,
-    beta: AutoRebalanceBetaState
-  })
-]);
-const RebalanceEvent = z.object({
-  id: z.uuid(),
-  autoRebalanceConfigId: z.uuid(),
-  positionId: z.uuid(),
-  weightSource: AutoRebalanceWeightSource,
-  driftPct: UnsignedDecimalString,
-  currentWeights: WeightMap,
-  targetWeights: WeightMap,
-  status: RebalanceEventStatus,
-  error: z.string().optional(),
-  createdAt: z.iso.datetime()
-});
-
-export { AutoRebalanceBetaState, AutoRebalanceConfig, AutoRebalancePausedReason, AutoRebalanceStatus, AutoRebalanceTimeframe, AutoRebalanceWeightSource, RebalanceEvent, RebalanceEventStatus, WeightMap };

package/dist/rebalance/index.js

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

package/dist/rebalance/payloads.js

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-import { ClientIdCode } from '../common/client-id';
-import { RefineWeightingSum, RefineUniqueSymbols } from '../common/refinement';
-import { UnsignedDecimalString } from '../common/schema';
-import { ExecutionOrderType } from '../execution';
-import { InstrumentId } from '../instrument';
-import { AutoRebalanceTimeframe, AutoRebalanceStatus } from './entities';
-
-const RebalanceManual = z.object({
-  orderType: ExecutionOrderType,
-  weightings: z.array(z.object({
-    symbol: InstrumentId,
-    weight: z.number().positive({
-      message: "Weight must be greater than 0"
-    }).max(1, {
-      message: "Weight must be less than 1"
-    })
-  })).superRefine(RefineWeightingSum).superRefine(RefineUniqueSymbols).describe("Array of weightings to rebalance the position"),
-  /**
-  * Attribution route code (client_ids.code)
-  */
-  clientId: ClientIdCode
-});
-const MinimumDriftPct = UnsignedDecimalString.refine((value) => Number(value) > 0 && Number(value) <= 1, {
-  message: "minimumDriftPct must be greater than 0 and at most 1"
-});
-const InitialWeightConfig = z.object({
-  weightSource: z.literal("INITIAL_WEIGHT"),
-  minimumDriftPct: MinimumDriftPct
-});
-const LiveBetaConfig = z.object({
-  weightSource: z.literal("LIVE_BETA"),
-  minimumDriftPct: MinimumDriftPct,
-  timeframe: AutoRebalanceTimeframe
-});
-const CreateInitialWeight = InitialWeightConfig.extend({
-  positionId: z.uuid()
-});
-const CreateLiveBeta = LiveBetaConfig.extend({
-  positionId: z.uuid()
-});
-const CreateAutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  CreateInitialWeight,
-  CreateLiveBeta
-]);
-const ReplaceAutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  InitialWeightConfig,
-  LiveBetaConfig
-]);
-const UpdateAutoRebalanceConfig = z.object({
-  minimumDriftPct: MinimumDriftPct.optional(),
-  timeframe: AutoRebalanceTimeframe.optional(),
-  status: AutoRebalanceStatus.optional()
-});
-
-export { CreateAutoRebalanceConfig, RebalanceManual, ReplaceAutoRebalanceConfig, UpdateAutoRebalanceConfig };

package/dist/rebalance/queries.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { normalizeArray, CursorFindParams } from '../common';
-import { AutoRebalanceStatus, AutoRebalanceWeightSource } from './entities';
-
-const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(AutoRebalanceStatus));
-const WeightSourceArray = z.preprocess((arg) => normalizeArray(arg), z.array(AutoRebalanceWeightSource));
-const AutoRebalanceListParams = CursorFindParams.extend({
-  status: StatusArray.optional(),
-  weightSource: WeightSourceArray.optional(),
-  positionId: z.uuid().optional()
-});
-const RebalanceEventListParams = CursorFindParams.extend({});
-
-export { AutoRebalanceListParams, RebalanceEventListParams };

package/dist/rebalance/responses.js

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-import { CursorResponse } from '../common';
-import { AutoRebalanceConfig, RebalanceEvent } from './entities';
-
-const RebalanceManualResponse = z.object({
-  plan: z.discriminatedUnion("outcome", [
-    z.object({
-      outcome: z.literal("full_rebalance")
-    }),
-    z.object({
-      outcome: z.literal("partial_rebalance"),
-      messages: z.tuple([
-        z.string()
-      ]).rest(z.string())
-    }),
-    z.object({
-      outcome: z.literal("no_rebalance"),
-      messages: z.tuple([
-        z.string()
-      ]).rest(z.string())
-    }),
-    // `failed` only occurs on background runs (dispatch/cron); MANUAL execution errors throw and surface as HTTP errors instead.
-    z.object({
-      outcome: z.literal("failed"),
-      messages: z.tuple([
-        z.string()
-      ]).rest(z.string())
-    })
-  ])
-});
-const AutoRebalanceListResponse = CursorResponse.extend({
-  items: z.array(AutoRebalanceConfig)
-});
-const CreateAutoRebalanceResponse = z.object({
-  config: AutoRebalanceConfig
-});
-const RebalanceEventListResponse = CursorResponse.extend({
-  items: z.array(RebalanceEvent)
-});
-
-export { AutoRebalanceListResponse, CreateAutoRebalanceResponse, RebalanceEventListResponse, RebalanceManualResponse };

package/dist/schedule/entities.js

@@ -1,239 +0,0 @@
-import { z } from 'zod';
-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 ScheduleCancelledReason = z.enum([
-  "POSITION_CLOSED",
-  "USER",
-  "SYSTEM",
-  "POSITION_NETTED",
-  "POSITION_LIQUIDATED",
-  "POSITION_REVERSED"
-]);
-const TWAPOpenLeg = z.object({
-  /** SYMBOL-MIGRATION switch-to-id: mirrors `symbol` today; becomes required once requests always carry `id`. */
-  id: InstrumentId.optional(),
-  /**
-  * Instrument ID
-  */
-  symbol: InstrumentId,
-  /**
-  * Side
-  */
-  side: Side,
-  /**
-  * Share of the parent target notional allocated to this leg
-  */
-  weight: AssetWeight
-});
-const BaseSchedule = z.object({
-  /**
-  * Schedule UUID
-  */
-  id: z.uuid(),
-  /**
-  * Connector
-  */
-  connector: Connector,
-  /**
-  * Schedule strategy
-  */
-  strategy: ScheduleStrategy,
-  /**
-  * Schedule status
-  */
-  status: ScheduleStatus,
-  /**
-  * Intent
-  */
-  intent: ScheduleIntent,
-  /**
-  * Position key
-  */
-  positionKey: z.string(),
-  /**
-  * Execution type
-  */
-  executionType: ScheduleExecutionType,
-  /**
-  * Last slice at timestamp
-  */
-  lastSliceAt: z.string().optional(),
-  /**
-  * Start at timestamp
-  */
-  startAt: z.string(),
-  /**
-  * End at timestamp
-  */
-  endAt: z.string(),
-  /**
-  * When the schedule was cancelled
-  */
-  cancelledAt: z.string().optional(),
-  /**
-  * Reason for the schedule being cancelled
-  */
-  cancelledReason: ScheduleCancelledReason.optional(),
-  /**
-  * Created at timestamp
-  */
-  createdAt: z.string(),
-  /**
-  * Updated at timestamp
-  */
-  updatedAt: z.string(),
-  /**
-  * Slices that produced live fills
-  */
-  executedSliceCount: z.number().int().nonnegative(),
-  /**
-  * Absolute USD filled across every slice
-  */
-  filledUsd: UnsignedDecimalString,
-  /**
-  * Absolute base quantity filled, per instrument
-  */
-  filledQuantities: z.record(InstrumentId, UnsignedDecimalString),
-  /**
-  * Overall progress from 0 to 1: notional filled for OPEN, the slowest leg for CLOSE
-  */
-  progress: z.number().min(0).max(1),
-  /**
-  * Progress of each leg from 0 to 1, capped at 1 when a leg overfills
-  */
-  legProgress: z.record(InstrumentId, z.number().min(0).max(1))
-});
-const TWAPOpen = BaseSchedule.extend({
-  /**
-  * Strategy
-  */
-  strategy: z.literal("TWAP"),
-  /**
-  * Intent
-  */
-  intent: z.literal("OPEN"),
-  /**
-  * Slice interval in seconds
-  */
-  sliceIntervalSec: z.number(),
-  /**
-  * Number of slices planned inside the execution window
-  */
-  sliceCount: z.number().int().positive(),
-  /**
-  * Bounded timing and basket-size randomization
-  */
-  randomization: TWAPRandomization,
-  /**
-  * Parent-order leg allocation
-  */
-  legs: z.array(TWAPOpenLeg),
-  /**
-  * Target notional
-  */
-  targetNotional: UnsignedDecimalString,
-  /**
-  * Remaining notional
-  */
-  remainingNotional: UnsignedDecimalString
-});
-const TWAPClose = BaseSchedule.extend({
-  /**
-  * Strategy
-  */
-  strategy: z.literal("TWAP"),
-  /**
-  * Intent
-  */
-  intent: z.literal("CLOSE"),
-  /**
-  * Slice interval in seconds
-  */
-  sliceIntervalSec: z.number(),
-  /**
-  * Number of slices planned inside the execution window
-  */
-  sliceCount: z.number().int().positive(),
-  /**
-  * Bounded timing and basket-size randomization
-  */
-  randomization: TWAPRandomization,
-  /**
-  * Position UUID
-  */
-  positionId: z.uuid(),
-  /**
-  * Initial exposure
-  */
-  initialExposure: z.record(InstrumentId, SignedDecimalString)
-});
-const Schedule = z.discriminatedUnion("intent", [
-  TWAPOpen,
-  TWAPClose
-]);
-const ScheduleSlicePosition = z.object({
-  /**
-  * Grid index of the slice inside the execution window
-  */
-  index: z.number().int().nonnegative(),
-  /**
-  * Grid time the slice is planned around, before timing jitter
-  */
-  scheduledAt: z.string()
-});
-const ScheduleSlice = z.discriminatedUnion("status", [
-  ScheduleSlicePosition.extend({
-    status: z.literal("EXECUTED"),
-    /**
-    * Absolute USD filled by the slice
-    */
-    usd: UnsignedDecimalString,
-    /**
-    * Absolute base quantity filled by the slice, per instrument
-    */
-    quantities: z.record(InstrumentId, UnsignedDecimalString),
-    /**
-    * Timestamp of the slice's latest fill
-    */
-    lastFilledAt: z.string(),
-    /**
-    * The slice's live fills in time order, present when requested with include=fills
-    */
-    fills: z.array(Fill).optional()
-  }),
-  ScheduleSlicePosition.extend({
-    /**
-    * Not yet reached on an active schedule
-    */
-    status: z.literal("PENDING")
-  }),
-  ScheduleSlicePosition.extend({
-    /**
-    * Passed without fills: skipped by catch-up, or before a finished schedule's last executed slice
-    */
-    status: z.literal("MISSED")
-  })
-]);
-
-export { Schedule, ScheduleCancelledReason, ScheduleExecutionType, ScheduleIntent, ScheduleSlice, ScheduleStatus, ScheduleStrategy, TWAPClose, TWAPOpen };

package/dist/schedule/index.js

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

package/dist/schedule/payloads.js

@@ -1,85 +0,0 @@
-import { z } from 'zod';
-import { ClientIdCode } from '../common/client-id';
-import { TWAPRandomization, DEFAULT_TWAP_RANDOMIZATION } from './randomization';
-import { FINAL_TWAP_SLICE_START_HEADROOM_SEC, TWAPSliceIntervalSec, TWAPTargetNotional, TWAPOpenLegs } from './twap-config';
-
-const BaseSchedule = z.object({
-  /**
-   * Start at date
-   */
-  startAt: z.coerce.date(),
-  /**
-   * End at date
-   */
-  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() >= FINAL_TWAP_SLICE_START_HEADROOM_SEC * 1e3, {
-  message: `TWAP execution window must be at least ${FINAL_TWAP_SLICE_START_HEADROOM_SEC} seconds`
-});
-const CreateTWAPOpen = BaseSchedule.safeExtend({
-  /**
-  * Strategy
-  */
-  strategy: z.literal("TWAP"),
-  /**
-  * Intent
-  */
-  intent: z.literal("OPEN"),
-  /**
-  * Execution type
-  */
-  executionType: z.literal("MARKET"),
-  /**
-  * Parent-order allocation for each leg
-  */
-  legs: TWAPOpenLegs,
-  /**
-  * Target notional
-  */
-  targetNotional: TWAPTargetNotional,
-  /**
-  * Slice interval in seconds
-  */
-  sliceIntervalSec: TWAPSliceIntervalSec,
-  /**
-  * Attribution route code (client_ids.code)
-  */
-  clientId: ClientIdCode
-});
-const CreateTWAPClose = BaseSchedule.safeExtend({
-  /**
-  * Strategy
-  */
-  strategy: z.literal("TWAP"),
-  /**
-  * Intent
-  */
-  intent: z.literal("CLOSE"),
-  /**
-  * Execution type
-  */
-  executionType: z.literal("MARKET"),
-  /**
-  * Position UUID
-  */
-  positionId: z.uuid(),
-  /**
-  * Slice interval in seconds
-  */
-  sliceIntervalSec: TWAPSliceIntervalSec,
-  /**
-  * Attribution route code (client_ids.code)
-  */
-  clientId: ClientIdCode
-});
-const CreateSchedule = z.discriminatedUnion("intent", [
-  CreateTWAPOpen,
-  CreateTWAPClose
-]);
-
-export { CreateSchedule, CreateTWAPClose, CreateTWAPOpen };

package/dist/schedule/queries.js

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import { normalizeArray, CursorFindParams } from '../common';
-import { Connector } from '../connector';
-
-const StatusEnum = z.enum([
-  "ACTIVE",
-  "COMPLETED",
-  "CANCELLED"
-]);
-const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(StatusEnum));
-const ScheduleListParams = CursorFindParams.extend({
-  connector: Connector.optional(),
-  status: StatusArray.optional()
-});
-const ScheduleDetailParams = z.object({
-  /**
-  * Slices per page; kept small so a page with fills stays bounded
-  */
-  limit: z.coerce.number().int().positive().max(100).optional().default(20),
-  /**
-  * Slice index the page starts at; pass the previous page's nextCursor as-is
-  */
-  cursor: z.coerce.number().int().nonnegative().optional(),
-  /**
-  * Nest each executed slice's live fills
-  */
-  include: z.literal("fills").optional()
-});
-
-export { ScheduleDetailParams, ScheduleListParams };

package/dist/schedule/randomization.js

@@ -1,15 +0,0 @@
-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 };

package/dist/schedule/responses.js

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { CursorResponse } from '../common';
-import { Schedule, ScheduleSlice } from './entities';
-
-const ScheduleListResponse = CursorResponse.extend({
-  schedules: z.array(Schedule)
-});
-const ScheduleDetailResponse = CursorResponse.extend({
-  schedule: Schedule,
-  slices: z.array(ScheduleSlice)
-});
-const CreateScheduleResponse = z.object({
-  schedule: Schedule
-});
-const CancelScheduleResponse = z.object({
-  id: z.uuid()
-});
-const CancelAllSchedulesResponse = z.object({
-  ids: z.array(z.uuid())
-});
-
-export { CancelAllSchedulesResponse, CancelScheduleResponse, CreateScheduleResponse, ScheduleDetailResponse, ScheduleListResponse };

package/dist/schedule/twap-config.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { RefineLegIdMatchesSymbol, RefineMinimumOneSymbol, RefineUniqueSymbols, RefineWeightingSum } from '../common/refinement';
-import { UnsignedDecimalString, AssetWeight, Side } from '../common/schema';
-import { InstrumentId } from '../instrument';
-
-const MAX_TWAP_DURATION_SEC = 60 * 60 * 24 * 31;
-const MIN_TWAP_SLICE_INTERVAL_SEC = 15;
-const FINAL_TWAP_SLICE_START_HEADROOM_SEC = 15;
-const TWAPSliceIntervalSec = z.int().min(MIN_TWAP_SLICE_INTERVAL_SEC).max(MAX_TWAP_DURATION_SEC);
-const TWAPTargetNotional = UnsignedDecimalString.refine((value) => /[1-9]/.test(value), {
-  message: "Target notional must be greater than zero"
-});
-const TWAPOpenLeg = z.object({
-  /** SYMBOL-MIGRATION switch-to-id: mirrors `symbol` today; becomes required once requests always carry `id`. */
-  id: InstrumentId.optional(),
-  /** Instrument ID. */
-  symbol: InstrumentId,
-  /** Direction to take. */
-  side: Side,
-  /** Share of the parent target notional allocated to this leg. */
-  weight: AssetWeight
-}).superRefine(RefineLegIdMatchesSymbol);
-const TWAPOpenLegs = z.array(TWAPOpenLeg).superRefine(RefineMinimumOneSymbol).superRefine(RefineUniqueSymbols).superRefine(RefineWeightingSum);
-const TriggerTWAPOpenLeg = TWAPOpenLeg.strict();
-const TriggerTWAPOpenLegs = z.tuple([
-  TriggerTWAPOpenLeg
-]).rest(TriggerTWAPOpenLeg).superRefine(RefineUniqueSymbols).superRefine(RefineWeightingSum);
-
-export { FINAL_TWAP_SLICE_START_HEADROOM_SEC, MAX_TWAP_DURATION_SEC, MIN_TWAP_SLICE_INTERVAL_SEC, TWAPOpenLeg, TWAPOpenLegs, TWAPSliceIntervalSec, TWAPTargetNotional, TriggerTWAPOpenLegs };