@pear-protocol/types 2.2.0 → 2.3.0

package/dist/bundle.d.ts

@@ -1,6 +1,7 @@
 export * from './auth';
 export * from './baskets/recommended';
 export * from './baskets/saved';
+export * from './common/address';
 export * from './common/trade-legs';
 export * from './connector';
 export * from './execution';

package/dist/bundle.js

@@ -1,6 +1,7 @@
 export * from './auth';
 export * from './baskets/recommended';
 export * from './baskets/saved';
+export * from './common/address';
 export * from './common/trade-legs';
 export * from './connector';
 export * from './execution';

package/dist/position/entities.d.ts

@@ -456,3 +456,123 @@ export declare const OpenPosition: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type OpenPosition = z.output<typeof OpenPosition>;
+/**
+ * The public, vault-scoped view of one open leg: what it has booked and what it still
+ * holds, with fees and funding withheld. Built by allowlist so a field added to
+ * `OpenPositionLeg` never reaches the public wire without a deliberate decision.
+ */
+export declare const VaultOpenPositionLeg: z.ZodObject<{
+    side: z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+    }>;
+    asset: z.ZodString;
+    realized: z.ZodObject<{
+        quantity: z.ZodString;
+        unpricedQuantity: z.ZodString;
+        exitVwap: z.ZodOptional<z.ZodString>;
+        grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    }, z.core.$strip>;
+    remaining: z.ZodObject<{
+        quantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        entryVwap: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type VaultOpenPositionLeg = z.output<typeof VaultOpenPositionLeg>;
+/**
+ * The public, vault-scoped view of one open position: position-level economics plus the
+ * reduced legs. No fee splits, no funding, no exposure sizing, no data-quality flags, no
+ * steps. Funding is withheld because attributing it replays the account's funding history
+ * since the position opened — a cost the anonymous route must not carry. Same allowlist
+ * rule as the leg — see `VaultOpenPositionLeg`.
+ */
+export declare const VaultOpenPosition: z.ZodObject<{
+    status: z.ZodLiteral<"OPEN">;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    updatedAt: z.ZodString;
+    positionId: z.ZodUUID;
+    openedAt: z.ZodString;
+    realizedGrossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    netCashflow: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    legs: z.ZodArray<z.ZodObject<{
+        side: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+        }>;
+        asset: z.ZodString;
+        realized: z.ZodObject<{
+            quantity: z.ZodString;
+            unpricedQuantity: z.ZodString;
+            exitVwap: z.ZodOptional<z.ZodString>;
+            grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        }, z.core.$strip>;
+        remaining: z.ZodObject<{
+            quantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            entryVwap: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VaultOpenPosition = z.output<typeof VaultOpenPosition>;
+/**
+ * The public, vault-scoped view of one closed leg: entry, exit and PnL, with fees, funding
+ * and committed-cash figures withheld. Same allowlist rule as `VaultOpenPositionLeg`.
+ */
+export declare const VaultClosedPositionLeg: z.ZodObject<{
+    side: z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+    }>;
+    asset: z.ZodString;
+    grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    entryVwap: z.ZodOptional<z.ZodString>;
+    exitVwap: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type VaultClosedPositionLeg = z.output<typeof VaultClosedPositionLeg>;
+/**
+ * The public, vault-scoped view of one closed position: lifecycle, position-level PnL and
+ * the reduced legs. Funding is withheld for the same reason as on `VaultOpenPosition`;
+ * `netPnl` never folds it in, so the published figures stay exact without it.
+ */
+export declare const VaultClosedPosition: z.ZodObject<{
+    status: z.ZodLiteral<"CLOSED">;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    closedReason: z.ZodOptional<z.ZodEnum<{
+        NETTED: "NETTED";
+        USER: "USER";
+        LIQUIDATED: "LIQUIDATED";
+    }>>;
+    closedAt: z.ZodString;
+    grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    positionId: z.ZodUUID;
+    openedAt: z.ZodString;
+    legs: z.ZodArray<z.ZodObject<{
+        side: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+        }>;
+        asset: z.ZodString;
+        grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        entryVwap: z.ZodOptional<z.ZodString>;
+        exitVwap: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VaultClosedPosition = z.output<typeof VaultClosedPosition>;

package/dist/position/entities.js

@@ -372,5 +372,42 @@ const OpenPosition = z.object({
   */
   steps: z.array(PositionStep).optional()
 });
+const VaultOpenPositionLeg = OpenPositionLeg.pick({
+  asset: true,
+  side: true,
+  realized: true,
+  remaining: true
+});
+const VaultOpenPosition = OpenPosition.pick({
+  positionId: true,
+  status: true,
+  connector: true,
+  openedAt: true,
+  updatedAt: true,
+  realizedGrossPnl: true,
+  netCashflow: true
+}).extend({
+  legs: z.array(VaultOpenPositionLeg)
+});
+const VaultClosedPositionLeg = ClosedPositionLeg.pick({
+  asset: true,
+  side: true,
+  entryVwap: true,
+  exitVwap: true,
+  grossPnl: true,
+  netPnl: true
+});
+const VaultClosedPosition = ClosedPosition.pick({
+  positionId: true,
+  status: true,
+  connector: true,
+  openedAt: true,
+  closedAt: true,
+  closedReason: true,
+  grossPnl: true,
+  netPnl: true
+}).extend({
+  legs: z.array(VaultClosedPositionLeg)
+});
 
-export { ClosedPosition, ClosedPositionLeg, ClosedPositionLegSide, OpenPosition, OpenPositionLeg, Position, PositionClosedReason, PositionEntryPrices, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionStep, PositionStepLeg, PositionTotalFundingPayment };
+export { ClosedPosition, ClosedPositionLeg, ClosedPositionLegSide, OpenPosition, OpenPositionLeg, Position, PositionClosedReason, PositionEntryPrices, PositionExposure, PositionInitialExposureUSD, PositionOrigin, PositionStatus, PositionStep, PositionStepLeg, PositionTotalFundingPayment, VaultClosedPosition, VaultClosedPositionLeg, VaultOpenPosition, VaultOpenPositionLeg };

package/dist/position/queries.d.ts

@@ -50,3 +50,31 @@ export declare const OpenPositionListParams: z.ZodObject<{
 }, z.core.$strip>;
 export type OpenPositionListParamsInput = z.input<typeof OpenPositionListParams>;
 export type OpenPositionListParams = z.output<typeof OpenPositionListParams>;
+/**
+ * Public vault open-position page.
+ *
+ * The vault is named by the path, never by an account id, and the page cannot be
+ * narrowed to one position or asked for steps: the public surface is a bounded
+ * history read only. Strict so an attempt to pass a private-route filter is refused
+ * rather than silently ignored.
+ */
+export declare const VaultOpenPositionListParams: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+}, z.core.$strict>;
+export type VaultOpenPositionListParamsInput = z.input<typeof VaultOpenPositionListParams>;
+export type VaultOpenPositionListParams = z.output<typeof VaultOpenPositionListParams>;
+/**
+ * Public vault closed-position page.
+ *
+ * Keeps the private route's close-time bounds and cap; drops `positionId` and
+ * `includeSteps` for the same reason as the open sibling.
+ */
+export declare const VaultClosedPositionListParams: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type VaultClosedPositionListParamsInput = z.input<typeof VaultClosedPositionListParams>;
+export type VaultClosedPositionListParams = z.output<typeof VaultClosedPositionListParams>;

package/dist/position/queries.js

@@ -94,5 +94,16 @@ const OpenPositionListParams = CursorFindParams.extend({
   ],
   message: "includeSteps requires positionId"
 });
+const VaultOpenPositionListParams = CursorFindParams.extend({
+  /** Same cap as the private open history: every row drags its fills along. */
+  limit: z.coerce.number().int().positive().max(200).optional().default(20)
+}).strict();
+const VaultClosedPositionListParams = CursorFindParams.extend({
+  /** Same cap as the private closed history: every row drags its fills along. */
+  limit: z.coerce.number().int().positive().max(200).optional().default(20),
+  /** Inclusive bounds on the close time, exactly as `ClosedPositionListParams` defines them. */
+  startDate: z.string().optional(),
+  endDate: z.string().optional()
+}).strict();
 
-export { ClosedPositionListParams, OpenPositionListParams, PositionListParams };
+export { ClosedPositionListParams, OpenPositionListParams, PositionListParams, VaultClosedPositionListParams, VaultOpenPositionListParams };

package/dist/position/responses.d.ts

@@ -294,3 +294,94 @@ export declare const OpenPositionListResponse: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type OpenPositionListResponse = z.output<typeof OpenPositionListResponse>;
+/**
+ * A public page of one vault's open positions, newest opened first.
+ *
+ * `vaultAddress` echoes the resolved (lowercased) vault so a client paging several
+ * vaults can tell the pages apart. Same paging rule as the private history: page until
+ * `nextCursor` is absent, never until a page comes back short.
+ */
+export declare const VaultOpenPositionListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    vaultAddress: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    positions: z.ZodArray<z.ZodObject<{
+        status: z.ZodLiteral<"OPEN">;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+            lighter_rhc: "lighter_rhc";
+        }>;
+        updatedAt: z.ZodString;
+        positionId: z.ZodUUID;
+        openedAt: z.ZodString;
+        realizedGrossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        netCashflow: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        legs: z.ZodArray<z.ZodObject<{
+            side: z.ZodEnum<{
+                LONG: "LONG";
+                SHORT: "SHORT";
+            }>;
+            asset: z.ZodString;
+            realized: z.ZodObject<{
+                quantity: z.ZodString;
+                unpricedQuantity: z.ZodString;
+                exitVwap: z.ZodOptional<z.ZodString>;
+                grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            }, z.core.$strip>;
+            remaining: z.ZodObject<{
+                quantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+                entryVwap: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VaultOpenPositionListResponse = z.output<typeof VaultOpenPositionListResponse>;
+/**
+ * A public page of one vault's closed positions, newest close first.
+ *
+ * A page may hold fewer than `limit` positions and still return a `nextCursor`, for the
+ * same reason as `ClosedPositionListResponse`. Page until `nextCursor` is absent.
+ */
+export declare const VaultClosedPositionListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    vaultAddress: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    positions: z.ZodArray<z.ZodObject<{
+        status: z.ZodLiteral<"CLOSED">;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+            lighter_rhc: "lighter_rhc";
+        }>;
+        closedReason: z.ZodOptional<z.ZodEnum<{
+            NETTED: "NETTED";
+            USER: "USER";
+            LIQUIDATED: "LIQUIDATED";
+        }>>;
+        closedAt: z.ZodString;
+        grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        positionId: z.ZodUUID;
+        openedAt: z.ZodString;
+        legs: z.ZodArray<z.ZodObject<{
+            side: z.ZodEnum<{
+                LONG: "LONG";
+                SHORT: "SHORT";
+            }>;
+            asset: z.ZodString;
+            grossPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            netPnl: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+            entryVwap: z.ZodOptional<z.ZodString>;
+            exitVwap: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VaultClosedPositionListResponse = z.output<typeof VaultClosedPositionListResponse>;

package/dist/position/responses.js

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { CursorResponse } from '../common';
+import { EthereumAddress } from '../common/address';
 import { SignedDecimalString } from '../common/schema';
 import { Connector } from '../connector';
 import { InstrumentId } from '../instrument';
-import { Position, PositionOrigin, ClosedPosition, OpenPosition } from './entities';
+import { Position, PositionOrigin, ClosedPosition, OpenPosition, VaultOpenPosition, VaultClosedPosition } from './entities';
 
 const PositionListResponse = CursorResponse.extend({
   positions: z.array(Position)
@@ -26,5 +27,13 @@ const ClosedPositionListResponse = CursorResponse.extend({
 const OpenPositionListResponse = CursorResponse.extend({
   positions: z.array(OpenPosition)
 });
+const VaultOpenPositionListResponse = CursorResponse.extend({
+  vaultAddress: EthereumAddress,
+  positions: z.array(VaultOpenPosition)
+});
+const VaultClosedPositionListResponse = CursorResponse.extend({
+  vaultAddress: EthereumAddress,
+  positions: z.array(VaultClosedPosition)
+});
 
-export { ClosedPositionListResponse, OpenPositionListResponse, OpenPositionLite, OpenPositionLiteListResponse, PositionListResponse };
+export { ClosedPositionListResponse, OpenPositionListResponse, OpenPositionLite, OpenPositionLiteListResponse, PositionListResponse, VaultClosedPositionListResponse, VaultOpenPositionListResponse };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/types",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Pear Protocol Types definitions",
   "private": false,
   "type": "module",