@pear-protocol/types 0.0.1

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './bundle';
+import * as bundle from './bundle';
+export { bundle as HttpTypes };

package/dist/instrument/entities.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const InstrumentId: z.ZodString;
+export type InstrumentId = z.infer<typeof InstrumentId>;
+export declare const InstrumentType: z.ZodEnum<{
+    spot: "spot";
+    perp: "perp";
+    hip3: "hip3";
+}>;
+export type InstrumentType = z.infer<typeof InstrumentType>;
+export declare const Instrument: z.ZodObject<{
+    id: z.ZodString;
+    base: z.ZodString;
+    quote: z.ZodString;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    type: z.ZodEnum<{
+        spot: "spot";
+        perp: "perp";
+        hip3: "hip3";
+    }>;
+    leverage: z.ZodInt;
+    precision: z.ZodObject<{
+        quantity: z.ZodObject<{
+            decimals: z.ZodInt;
+            step: z.ZodNumber;
+            contractSize: z.ZodNumber;
+        }, z.core.$strip>;
+        price: z.ZodObject<{
+            decimals: z.ZodInt;
+            tick: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+            sigFigs: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodInt, z.ZodTransform<number | undefined, number>>>>;
+        }, z.core.$strip>;
+        notional: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+            max: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Instrument = z.output<typeof Instrument>;

package/dist/instrument/entities.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { Connector } from '../connector';
+import { InstrumentPrecision } from '../instrument-precision';
+
+const InstrumentId = z.string();
+const InstrumentType = z.enum(["spot", "perp", "hip3"]);
+const Instrument = z.object({
+  /**
+   * Exchange specific instrument identifier
+   * @example (dexIndex + assetIndex) on Hyperliquid
+   * @example "BTCUSDT" on Binance
+   */
+  id: InstrumentId,
+  /**
+   * The base asset of the instrument.
+   * @example "BTC"
+   */
+  base: z.string(),
+  /**
+   * The quote asset of the instrument.
+   * @example "USDT"
+   */
+  quote: z.string(),
+  /**
+   * The connector of the instrument.
+   * @example "hyperliquid"
+   * @example "binanceusdm"
+   */
+  connector: Connector,
+  /**
+   * The type of the instrument.
+   * @example "spot"
+   * @example "perp"
+   * @example "hip3"
+   */
+  type: InstrumentType,
+  /**
+   * The maximum leverage of the instrument.
+   * @example 1
+   */
+  leverage: z.int().min(1),
+  /**
+   * The precision of the instrument.
+   */
+  precision: InstrumentPrecision
+});
+
+export { Instrument, InstrumentId, InstrumentType };

package/dist/instrument/index.d.ts

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

package/dist/instrument/index.js

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

package/dist/instrument/queries.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const InstrumentListParams: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+}, z.core.$strip>;
+export type InstrumentListParams = z.output<typeof InstrumentListParams>;

package/dist/instrument/queries.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { Connector } from '../connector';
+
+const InstrumentListParams = z.object({
+  connector: Connector
+});
+
+export { InstrumentListParams };

package/dist/instrument/responses.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const InstrumentListResponse: z.ZodObject<{
+    instruments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        base: z.ZodString;
+        quote: z.ZodString;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        type: z.ZodEnum<{
+            spot: "spot";
+            perp: "perp";
+            hip3: "hip3";
+        }>;
+        leverage: z.ZodInt;
+        precision: z.ZodObject<{
+            quantity: z.ZodObject<{
+                decimals: z.ZodInt;
+                step: z.ZodNumber;
+                contractSize: z.ZodNumber;
+            }, z.core.$strip>;
+            price: z.ZodObject<{
+                decimals: z.ZodInt;
+                tick: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+                sigFigs: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodInt, z.ZodTransform<number | undefined, number>>>>;
+            }, z.core.$strip>;
+            notional: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+                max: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type InstrumentListResponse = z.output<typeof InstrumentListResponse>;

package/dist/instrument/responses.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { Instrument } from './entities';
+
+const InstrumentListResponse = z.object({
+  /**
+   * The list of instruments.
+   */
+  instruments: z.array(Instrument)
+});
+
+export { InstrumentListResponse };

package/dist/instrument-precision/index.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const InstrumentPrecision: z.ZodObject<{
+    quantity: z.ZodObject<{
+        decimals: z.ZodInt;
+        step: z.ZodNumber;
+        contractSize: z.ZodNumber;
+    }, z.core.$strip>;
+    price: z.ZodObject<{
+        decimals: z.ZodInt;
+        tick: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+        sigFigs: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodInt, z.ZodTransform<number | undefined, number>>>>;
+    }, z.core.$strip>;
+    notional: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+        max: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type InstrumentPrecision = z.output<typeof InstrumentPrecision>;

package/dist/instrument-precision/index.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+const InstrumentPrecision = z.object({
+  quantity: z.object({
+    /**
+     * The maximum number of decimals accepted.
+     * @example 4 for a 0.0001 step size.
+     */
+    decimals: z.int(),
+    /**
+     * The smallest step size.
+     * @example 0.01 for a 2 decimal precision.
+     */
+    step: z.number(),
+    /**
+     * Size of one contract in base asset units.
+     * For exchanges where 1 contract != 1 base unit (e.g., OKX: 1 contract = 0.01 BTC).
+     * 1 means 1:1 mapping (most exchanges).
+     */
+    contractSize: z.number()
+  }),
+  price: z.object({
+    /**
+     * The maximum number of decimals.
+     * @example 4 for a 0.0001 tick size.
+     */
+    decimals: z.int(),
+    /**
+     * The smallest increment.
+     * @example 0.01 for a 2 decimal precision.
+     */
+    tick: z.number().transform((val) => val === null ? void 0 : val).optional().nullable(),
+    /**
+     * The number of significant figures.
+     * @example 5 on Hyperliquid V2.
+     */
+    sigFigs: z.int().transform((val) => val === null ? void 0 : val).optional().nullable()
+  }),
+  notional: z.object({
+    /**
+     * The minimum notional amount in USD.
+     */
+    min: z.number().transform((val) => val === null ? void 0 : val).optional().nullable(),
+    /**
+     * The maximum notional amount in USD.
+     */
+    max: z.number().transform((val) => val === null ? void 0 : val).optional().nullable()
+  }).optional()
+});
+
+export { InstrumentPrecision };

package/dist/misc/index.d.ts

@@ -0,0 +1,3 @@
+export type UnsignedDecimalString = string;
+export type SignedDecimalString = string;
+export type Side = 'BUY' | 'SELL';

package/dist/misc/index.js

@@ -0,0 +1 @@
+

package/dist/order/entities.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+export declare const OrderStatus: z.ZodEnum<{
+    PENDING: "PENDING";
+    PARTIAL: "PARTIAL";
+    FILLED: "FILLED";
+    CANCELLED: "CANCELLED";
+    REJECTED: "REJECTED";
+}>;
+export type OrderStatus = z.infer<typeof OrderStatus>;
+export declare const MarketOrder: z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        PENDING: "PENDING";
+        PARTIAL: "PARTIAL";
+        FILLED: "FILLED";
+        CANCELLED: "CANCELLED";
+        REJECTED: "REJECTED";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    type: z.ZodLiteral<"MARKET">;
+    symbol: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    reduceOnly: z.ZodBoolean;
+    leverage: z.ZodInt;
+    quantity: z.ZodString;
+    price: z.ZodString;
+    filledQuantity: z.ZodString;
+    filledPrice: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const Order: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        PENDING: "PENDING";
+        PARTIAL: "PARTIAL";
+        FILLED: "FILLED";
+        CANCELLED: "CANCELLED";
+        REJECTED: "REJECTED";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    type: z.ZodLiteral<"MARKET">;
+    symbol: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    reduceOnly: z.ZodBoolean;
+    leverage: z.ZodInt;
+    quantity: z.ZodString;
+    price: z.ZodString;
+    filledQuantity: z.ZodString;
+    filledPrice: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Order = z.output<typeof Order>;
+export type MarketOrder = z.output<typeof MarketOrder>;

package/dist/order/entities.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { UnsignedDecimalString, Leverage, Side } from '../common/schema';
+import { Connector } from '../connector';
+import { InstrumentId } from '../instrument';
+
+const OrderStatus = z.enum(["PENDING", "PARTIAL", "FILLED", "CANCELLED", "REJECTED"]);
+const BaseOrder = z.object({
+  /**
+   * Order UUID
+   */
+  id: z.uuid(),
+  /**
+   * Connector
+   */
+  connector: Connector,
+  /**
+   * Order status
+   */
+  status: OrderStatus,
+  /**
+   * Error message
+   */
+  error: z.string().optional(),
+  /**
+   * Created at timestamp
+   */
+  createdAt: z.string(),
+  /**
+   * Updated at timestamp
+   */
+  updatedAt: z.string()
+});
+const MarketOrder = BaseOrder.extend({
+  /**
+   * Order type
+   */
+  type: z.literal("MARKET"),
+  /**
+   * Instrument ID
+   */
+  symbol: InstrumentId,
+  /**
+   * Side
+   */
+  side: Side,
+  /**
+   * Reduce only flag
+   */
+  reduceOnly: z.boolean(),
+  /**
+   * Leverage
+   */
+  leverage: Leverage,
+  /**
+   * Contract quantity to trade
+   */
+  quantity: UnsignedDecimalString,
+  /**
+   * Price
+   */
+  price: UnsignedDecimalString,
+  /**
+   * Filled contract quantity
+   */
+  filledQuantity: UnsignedDecimalString,
+  /**
+   * Filled price
+   */
+  filledPrice: UnsignedDecimalString.optional()
+});
+const Order = z.discriminatedUnion("type", [BaseOrder.extend(MarketOrder.shape)]);
+
+export { MarketOrder, Order, OrderStatus };

package/dist/order/index.d.ts

@@ -0,0 +1 @@
+export * from './entities';

package/dist/order/index.js

@@ -0,0 +1 @@
+export * from './entities';

package/dist/position/entities.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const PositionStatus: z.ZodEnum<{
+    OPEN: "OPEN";
+    CLOSED: "CLOSED";
+}>;
+export type PositionStatus = z.infer<typeof PositionStatus>;
+export declare const PositionClosedReason: z.ZodEnum<{
+    NETTED: "NETTED";
+    USER: "USER";
+    LIQUIDATED: "LIQUIDATED";
+}>;
+export type PositionClosedReason = z.infer<typeof PositionClosedReason>;
+/**
+ * The exposure of a position in directional units for each asset.
+ *
+ * @example { '0': '0.002' } means BTC 0.002 LONG
+ * @example { '1': '-0.5' } means ETH 0.5 SHORT
+ */
+export declare const PositionExposure: z.ZodRecord<z.ZodString, z.ZodString>;
+export type PositionExposure = z.infer<typeof PositionExposure>;
+/**
+ * The initial exposure in directional USD for each asset.
+ *
+ * @example { '0': 1000 } means BTC 1000 USD LONG
+ * @example { '1': -500 } means ETH 500 USD SHORT
+ */
+export declare const PositionInitialExposureUSD: z.ZodRecord<z.ZodString, z.ZodString>;
+export type PositionInitialExposureUSD = z.infer<typeof PositionInitialExposureUSD>;
+export declare const Position: z.ZodObject<{
+    id: z.ZodUUID;
+    tradeAccountId: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+    status: z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+    }>;
+    closedReason: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        NETTED: "NETTED";
+        USER: "USER";
+        LIQUIDATED: "LIQUIDATED";
+    }>>>;
+    exposure: z.ZodRecord<z.ZodString, z.ZodString>;
+    closedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type Position = z.output<typeof Position>;

package/dist/position/entities.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { SignedDecimalString } from '../common/schema';
+import { Connector } from '../connector';
+import { InstrumentId } from '../instrument';
+
+const PositionStatus = z.enum(["OPEN", "CLOSED"]);
+const PositionClosedReason = z.enum(["NETTED", "USER", "LIQUIDATED"]);
+const PositionExposure = z.record(InstrumentId, SignedDecimalString);
+const PositionInitialExposureUSD = z.record(InstrumentId, SignedDecimalString);
+const Position = z.object({
+  /**
+   * Position UUID
+   */
+  id: z.uuid(),
+  /**
+   * Trade account UUID
+   */
+  tradeAccountId: z.uuid(),
+  /**
+   * Connector
+   */
+  connector: Connector,
+  /**
+   * Position status
+   */
+  status: PositionStatus,
+  /**
+   * Closed reason
+   */
+  closedReason: PositionClosedReason.nullable().optional(),
+  /**
+   * Position exposure
+   */
+  exposure: PositionExposure,
+  /**
+   * Closed at timestamp
+   */
+  closedAt: z.string().nullable().optional(),
+  /**
+   * The exposure expressed in USD at the time
+   * the position was opened. It does not change
+   * on adjustments, and is only used for UI purposes.
+   */
+  initialExposureUSD: PositionInitialExposureUSD,
+  /**
+   * Created at timestamp
+   */
+  createdAt: z.string(),
+  /**
+   * Updated at timestamp
+   */
+  updatedAt: z.string()
+});
+
+export { Position, PositionClosedReason, PositionExposure, PositionInitialExposureUSD, PositionStatus };

package/dist/position/index.d.ts

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

package/dist/position/index.js

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

package/dist/position/queries.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const PositionListParams: z.ZodObject<{
+    connector: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>>;
+    status: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | (("OPEN" | "CLOSED")[] & any[]) | undefined, ("OPEN" | "CLOSED")[]>, z.ZodArray<z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+    }>>>>;
+    orderBy: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"createdAt">, z.ZodLiteral<"-createdAt">, z.ZodLiteral<"updatedAt">, z.ZodLiteral<"-updatedAt">]>>;
+}, z.core.$strip>;
+export type PositionListParamsInput = z.input<typeof PositionListParams>;
+export type PositionListParams = z.output<typeof PositionListParams>;

package/dist/position/queries.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { normalizeArray } from '../common';
+import { Connector } from '../connector';
+
+const OrderBy = z.union([
+  z.literal("createdAt"),
+  z.literal("-createdAt"),
+  z.literal("updatedAt"),
+  z.literal("-updatedAt")
+]);
+const StatusEnum = z.enum(["OPEN", "CLOSED"]);
+const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(StatusEnum));
+const PositionListParams = z.object({
+  /**
+   * Connector filter
+   */
+  connector: Connector.optional(),
+  /**
+   * Status filter
+   */
+  status: StatusArray.optional(),
+  /**
+   * Order by field
+   */
+  orderBy: OrderBy.default("-createdAt")
+});
+
+export { PositionListParams };

package/dist/position/responses.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const PositionListResponse: z.ZodObject<{
+    positions: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        tradeAccountId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        status: z.ZodEnum<{
+            OPEN: "OPEN";
+            CLOSED: "CLOSED";
+        }>;
+        closedReason: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            NETTED: "NETTED";
+            USER: "USER";
+            LIQUIDATED: "LIQUIDATED";
+        }>>>;
+        exposure: z.ZodRecord<z.ZodString, z.ZodString>;
+        closedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        initialExposureUSD: z.ZodRecord<z.ZodString, z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PositionListResponse = z.output<typeof PositionListResponse>;

package/dist/position/responses.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { Position } from './entities';
+
+const PositionListResponse = z.object({
+  positions: z.array(Position)
+});
+
+export { PositionListResponse };

package/dist/price/entities.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const PriceSource: z.ZodEnum<{
+    mid: "mid";
+    mark: "mark";
+}>;
+export type PriceSource = z.infer<typeof PriceSource>;
+export declare const InstrumentPriceMap: z.ZodRecord<z.ZodString, z.ZodString>;
+export type InstrumentPriceMap = z.output<typeof InstrumentPriceMap>;

package/dist/price/entities.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { InstrumentId } from '../instrument';
+
+const PriceSource = z.enum(["mid", "mark"]);
+const InstrumentPriceMap = z.record(InstrumentId, z.string());
+
+export { InstrumentPriceMap, PriceSource };

package/dist/price/index.d.ts

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

package/dist/price/index.js

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

package/dist/price/queries.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const PricesQueryParams: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>;
+}, z.core.$strip>;
+export type PricesQueryParams = z.output<typeof PricesQueryParams>;

package/dist/price/queries.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { Connector } from '../connector';
+
+const PricesQueryParams = z.object({
+  connector: Connector
+});
+
+export { PricesQueryParams };