@pear-protocol/types 0.0.1

package/dist/price/responses.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const PricesResponse: z.ZodObject<{
+    mid: z.ZodRecord<z.ZodString, z.ZodString>;
+    mark: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type PricesResponse = z.output<typeof PricesResponse>;

package/dist/price/responses.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { InstrumentPriceMap } from './entities';
+
+const PricesResponse = z.object({
+  /**
+   * Mid prices for instruments
+   */
+  mid: InstrumentPriceMap,
+  /**
+   * Mark prices for instruments
+   */
+  mark: InstrumentPriceMap
+});
+
+export { PricesResponse };

package/dist/schedule/entities.d.ts

@@ -0,0 +1,380 @@
+import { z } from 'zod';
+export declare const ScheduleStrategy: z.ZodEnum<{
+    TWAP: "TWAP";
+    VWAP: "VWAP";
+}>;
+export type ScheduleStrategy = z.infer<typeof ScheduleStrategy>;
+export declare const ScheduleStatus: z.ZodEnum<{
+    CANCELLED: "CANCELLED";
+    ACTIVE: "ACTIVE";
+    COMPLETED: "COMPLETED";
+    FAILED: "FAILED";
+}>;
+export type ScheduleStatus = z.infer<typeof ScheduleStatus>;
+export declare const ScheduleIntent: z.ZodEnum<{
+    OPEN: "OPEN";
+    CLOSE: "CLOSE";
+}>;
+export type ScheduleIntent = z.infer<typeof ScheduleIntent>;
+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";
+    SYSTEM: "SYSTEM";
+}>;
+export type ScheduleCancelledReason = z.infer<typeof ScheduleCancelledReason>;
+declare const TWAPSliceOpenLeg: 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;
+}, z.core.$strip>;
+declare const BaseSchedule: z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    strategy: z.ZodEnum<{
+        TWAP: "TWAP";
+        VWAP: "VWAP";
+    }>;
+    status: z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+        FAILED: "FAILED";
+    }>;
+    intent: z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSE: "CLOSE";
+    }>;
+    positionKey: z.ZodString;
+    executionType: z.ZodEnum<{
+        MARKET: "MARKET";
+    }>;
+    lastSliceAt: z.ZodOptional<z.ZodString>;
+    startAt: z.ZodString;
+    endAt: z.ZodString;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelledReason: z.ZodOptional<z.ZodEnum<{
+        USER: "USER";
+        POSITION_CLOSED: "POSITION_CLOSED";
+        SYSTEM: "SYSTEM";
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        cloid: z.ZodOptional<z.ZodUUID>;
+        tradeAccountId: z.ZodUUID;
+        symbol: z.ZodString;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+        usd: z.ZodString;
+        fee: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const TWAPOpen: z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+        FAILED: "FAILED";
+    }>;
+    positionKey: z.ZodString;
+    executionType: z.ZodEnum<{
+        MARKET: "MARKET";
+    }>;
+    lastSliceAt: z.ZodOptional<z.ZodString>;
+    startAt: z.ZodString;
+    endAt: z.ZodString;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelledReason: z.ZodOptional<z.ZodEnum<{
+        USER: "USER";
+        POSITION_CLOSED: "POSITION_CLOSED";
+        SYSTEM: "SYSTEM";
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        cloid: z.ZodOptional<z.ZodUUID>;
+        tradeAccountId: z.ZodUUID;
+        symbol: z.ZodString;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+        usd: z.ZodString;
+        fee: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+    strategy: z.ZodLiteral<"TWAP">;
+    intent: z.ZodLiteral<"OPEN">;
+    sliceIntervalMs: z.ZodNumber;
+    sliceLegs: z.ZodArray<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>>;
+    targetNotional: z.ZodString;
+    remainingNotional: z.ZodString;
+}, z.core.$strip>;
+export declare const TWAPClose: z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+        FAILED: "FAILED";
+    }>;
+    positionKey: z.ZodString;
+    executionType: z.ZodEnum<{
+        MARKET: "MARKET";
+    }>;
+    lastSliceAt: z.ZodOptional<z.ZodString>;
+    startAt: z.ZodString;
+    endAt: z.ZodString;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelledReason: z.ZodOptional<z.ZodEnum<{
+        USER: "USER";
+        POSITION_CLOSED: "POSITION_CLOSED";
+        SYSTEM: "SYSTEM";
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        cloid: z.ZodOptional<z.ZodUUID>;
+        tradeAccountId: z.ZodUUID;
+        symbol: z.ZodString;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+        usd: z.ZodString;
+        fee: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+    strategy: z.ZodLiteral<"TWAP">;
+    intent: z.ZodLiteral<"CLOSE">;
+    sliceIntervalMs: z.ZodNumber;
+    positionId: z.ZodUUID;
+    sliceLegs: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        stepAmount: z.ZodString;
+    }, z.core.$strip>>;
+    initialExposure: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export declare const Schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+        FAILED: "FAILED";
+    }>;
+    positionKey: z.ZodString;
+    executionType: z.ZodEnum<{
+        MARKET: "MARKET";
+    }>;
+    lastSliceAt: z.ZodOptional<z.ZodString>;
+    startAt: z.ZodString;
+    endAt: z.ZodString;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelledReason: z.ZodOptional<z.ZodEnum<{
+        USER: "USER";
+        POSITION_CLOSED: "POSITION_CLOSED";
+        SYSTEM: "SYSTEM";
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        cloid: z.ZodOptional<z.ZodUUID>;
+        tradeAccountId: z.ZodUUID;
+        symbol: z.ZodString;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+        usd: z.ZodString;
+        fee: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+    strategy: z.ZodLiteral<"TWAP">;
+    intent: z.ZodLiteral<"OPEN">;
+    sliceIntervalMs: z.ZodNumber;
+    sliceLegs: z.ZodArray<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>>;
+    targetNotional: z.ZodString;
+    remainingNotional: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+        FAILED: "FAILED";
+    }>;
+    positionKey: z.ZodString;
+    executionType: z.ZodEnum<{
+        MARKET: "MARKET";
+    }>;
+    lastSliceAt: z.ZodOptional<z.ZodString>;
+    startAt: z.ZodString;
+    endAt: z.ZodString;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelledReason: z.ZodOptional<z.ZodEnum<{
+        USER: "USER";
+        POSITION_CLOSED: "POSITION_CLOSED";
+        SYSTEM: "SYSTEM";
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        cloid: z.ZodOptional<z.ZodUUID>;
+        tradeAccountId: z.ZodUUID;
+        symbol: z.ZodString;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+        usd: z.ZodString;
+        fee: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+    strategy: z.ZodLiteral<"TWAP">;
+    intent: z.ZodLiteral<"CLOSE">;
+    sliceIntervalMs: z.ZodNumber;
+    positionId: z.ZodUUID;
+    sliceLegs: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        stepAmount: z.ZodString;
+    }, z.core.$strip>>;
+    initialExposure: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>], "intent">;
+export type TWAPSliceOpenLeg = z.output<typeof TWAPSliceOpenLeg>;
+export type TWAPSliceCloseLeg = z.output<typeof TWAPSliceCloseLeg>;
+export type BaseSchedule = z.output<typeof BaseSchedule>;
+export type TWAPOpen = z.output<typeof TWAPOpen>;
+export type TWAPClose = z.output<typeof TWAPClose>;
+export type Schedule = z.output<typeof Schedule>;
+export {};

package/dist/schedule/entities.js

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+import { UnsignedDecimalString, Side, SignedDecimalString } from '../common/schema';
+import { Connector } from '../connector';
+import { Fill } from '../fill/entities';
+import { InstrumentId } from '../instrument';
+
+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", "SYSTEM"]);
+const TWAPSliceOpenLeg = z.object({
+  /**
+   * Instrument ID
+   */
+  symbol: InstrumentId,
+  /**
+   * Side
+   */
+  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
+   */
+  stepAmount: UnsignedDecimalString
+});
+const TWAPSliceCloseLeg = z.object({
+  /**
+   * Instrument ID
+   */
+  symbol: InstrumentId,
+  /**
+   * Step amount
+   */
+  stepAmount: UnsignedDecimalString
+});
+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(),
+  /**
+   * Fills
+   */
+  fills: z.array(Fill).optional()
+});
+const TWAPOpen = BaseSchedule.extend({
+  /**
+   * Strategy
+   */
+  strategy: z.literal("TWAP"),
+  /**
+   * Intent
+   */
+  intent: z.literal("OPEN"),
+  /**
+   * Slice interval in milliseconds
+   */
+  sliceIntervalMs: z.number(),
+  /**
+   * Slice legs
+   */
+  sliceLegs: z.array(TWAPSliceOpenLeg),
+  /**
+   * 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 milliseconds
+   */
+  sliceIntervalMs: z.number(),
+  /**
+   * Position UUID
+   */
+  positionId: z.uuid(),
+  /**
+   * Slice legs
+   */
+  sliceLegs: z.array(TWAPSliceCloseLeg),
+  /**
+   * Initial exposure
+   */
+  initialExposure: z.record(InstrumentId, SignedDecimalString)
+});
+const Schedule = z.discriminatedUnion("intent", [TWAPOpen, TWAPClose]);
+
+export { Schedule, ScheduleCancelledReason, ScheduleExecutionType, ScheduleIntent, ScheduleSliceMode, ScheduleStatus, ScheduleStrategy, TWAPClose, TWAPOpen };

package/dist/schedule/index.d.ts

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

package/dist/schedule/index.js

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

package/dist/schedule/payloads.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+declare const CreateTWAPOpen: z.ZodObject<{
+    startAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    endAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    strategy: z.ZodLiteral<"TWAP">;
+    intent: z.ZodLiteral<"OPEN">;
+    executionType: z.ZodLiteral<"MARKET">;
+    sliceLegs: z.ZodArray<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>>;
+    targetNotional: z.ZodString;
+    sliceIntervalMs: z.ZodInt;
+}, z.core.$strip>;
+declare const CreateTWAPClose: z.ZodObject<{
+    startAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    endAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    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;
+    sliceIntervalMs: z.ZodInt;
+}, z.core.$strip>;
+export declare const CreateSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    startAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    endAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    strategy: z.ZodLiteral<"TWAP">;
+    intent: z.ZodLiteral<"OPEN">;
+    executionType: z.ZodLiteral<"MARKET">;
+    sliceLegs: z.ZodArray<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>>;
+    targetNotional: z.ZodString;
+    sliceIntervalMs: z.ZodInt;
+}, z.core.$strip>, z.ZodObject<{
+    startAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    endAt: z.ZodDefault<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    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;
+    sliceIntervalMs: z.ZodInt;
+}, z.core.$strip>], "intent">;
+export type CreateTWAPOpen = z.output<typeof CreateTWAPOpen>;
+export type CreateTWAPClose = z.output<typeof CreateTWAPClose>;
+export type CreateSchedule = z.output<typeof CreateSchedule>;
+export {};