@pear-protocol/types 1.24.0 → 1.25.0

package/dist/rebalance/responses.js

@@ -9,23 +9,31 @@ const RebalanceManualResponse = z.object({
     }),
     z.object({
       outcome: z.literal("partial_rebalance"),
-      messages: z.tuple([z.string()]).rest(z.string())
+      messages: z.tuple([
+        z.string()
+      ]).rest(z.string())
     }),
     z.object({
       outcome: z.literal("no_rebalance"),
-      messages: z.tuple([z.string()]).rest(z.string())
+      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())
+      messages: z.tuple([
+        z.string()
+      ]).rest(z.string())
     })
   ])
 });
 const AutoRebalanceListResponse = CursorResponse.extend({
   items: z.array(AutoRebalanceConfig)
 });
-const CreateAutoRebalanceResponse = z.object({ config: AutoRebalanceConfig });
+const CreateAutoRebalanceResponse = z.object({
+  config: AutoRebalanceConfig
+});
 const RebalanceEventListResponse = CursorResponse.extend({
   items: z.array(RebalanceEvent)
 });

package/dist/saved-baskets/entities.js

@@ -10,7 +10,9 @@ const SavedBasketLeg = z.object({
 const SavedBasket = z.object({
   id: z.uuid(),
   name: z.string(),
-  legs: z.tuple([SavedBasketLeg]).rest(SavedBasketLeg),
+  legs: z.tuple([
+    SavedBasketLeg
+  ]).rest(SavedBasketLeg),
   createdAt: z.string(),
   updatedAt: z.string()
 });

package/dist/saved-baskets/payloads.js

@@ -3,7 +3,9 @@ import { RefineUniqueSymbols, RefineWeightingSum } from '../common/refinement';
 import { SavedBasketLeg } from './entities';
 
 const SavedBasketName = z.string().trim().min(1, "Name is required").max(48).describe("Display name, unique per trade account (case-insensitive)");
-const SavedBasketLegs = z.tuple([SavedBasketLeg]).rest(SavedBasketLeg).superRefine(RefineUniqueSymbols).superRefine(RefineWeightingSum).refine((value) => value.length <= 20, "Basket must have at most 20 legs").describe("At least one leg, up to 20");
+const SavedBasketLegs = z.tuple([
+  SavedBasketLeg
+]).rest(SavedBasketLeg).superRefine(RefineUniqueSymbols).superRefine(RefineWeightingSum).refine((value) => value.length <= 20, "Basket must have at most 20 legs").describe("At least one leg, up to 20");
 const CreateSavedBasketPayload = z.object({
   name: SavedBasketName,
   legs: SavedBasketLegs

package/dist/schedule/entities.js

@@ -5,10 +5,23 @@ 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 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",
@@ -18,144 +31,147 @@ const ScheduleCancelledReason = z.enum([
 ]);
 const TWAPOpenLeg = z.object({
   /**
-   * Instrument ID
-   */
+  * Instrument ID
+  */
   symbol: InstrumentId,
   /**
-   * Side
-   */
+  * Side
+  */
   side: Side,
   /**
-   * Share of the parent target notional allocated to this leg
-   */
+  * Share of the parent target notional allocated to this leg
+  */
   weight: AssetWeight
 });
 const BaseSchedule = z.object({
   /**
-   * Schedule UUID
-   */
+  * Schedule UUID
+  */
   id: z.uuid(),
   /**
-   * Connector
-   */
+  * Connector
+  */
   connector: Connector,
   /**
-   * Schedule strategy
-   */
+  * Schedule strategy
+  */
   strategy: ScheduleStrategy,
   /**
-   * Schedule status
-   */
+  * Schedule status
+  */
   status: ScheduleStatus,
   /**
-   * Intent
-   */
+  * Intent
+  */
   intent: ScheduleIntent,
   /**
-   * Position key
-   */
+  * Position key
+  */
   positionKey: z.string(),
   /**
-   * Execution type
-   */
+  * Execution type
+  */
   executionType: ScheduleExecutionType,
   /**
-   * Last slice at timestamp
-   */
+  * Last slice at timestamp
+  */
   lastSliceAt: z.string().optional(),
   /**
-   * Start at timestamp
-   */
+  * Start at timestamp
+  */
   startAt: z.string(),
   /**
-   * End at timestamp
-   */
+  * End at timestamp
+  */
   endAt: z.string(),
   /**
-   * When the schedule was cancelled
-   */
+  * When the schedule was cancelled
+  */
   cancelledAt: z.string().optional(),
   /**
-   * Reason for the schedule being cancelled
-   */
+  * Reason for the schedule being cancelled
+  */
   cancelledReason: ScheduleCancelledReason.optional(),
   /**
-   * Created at timestamp
-   */
+  * Created at timestamp
+  */
   createdAt: z.string(),
   /**
-   * Updated at timestamp
-   */
+  * Updated at timestamp
+  */
   updatedAt: z.string(),
   /**
-   * Fills
-   */
+  * Fills
+  */
   fills: z.array(Fill).optional()
 });
 const TWAPOpen = BaseSchedule.extend({
   /**
-   * Strategy
-   */
+  * Strategy
+  */
   strategy: z.literal("TWAP"),
   /**
-   * Intent
-   */
+  * Intent
+  */
   intent: z.literal("OPEN"),
   /**
-   * Slice interval in seconds
-   */
+  * Slice interval in seconds
+  */
   sliceIntervalSec: z.number(),
   /**
-   * Number of slices planned inside the execution window
-   */
+  * Number of slices planned inside the execution window
+  */
   sliceCount: z.number().int().positive(),
   /**
-   * Bounded timing and basket-size randomization
-   */
+  * Bounded timing and basket-size randomization
+  */
   randomization: TWAPRandomization,
   /**
-   * Parent-order leg allocation
-   */
+  * Parent-order leg allocation
+  */
   legs: z.array(TWAPOpenLeg),
   /**
-   * Target notional
-   */
+  * Target notional
+  */
   targetNotional: UnsignedDecimalString,
   /**
-   * Remaining notional
-   */
+  * Remaining notional
+  */
   remainingNotional: UnsignedDecimalString
 });
 const TWAPClose = BaseSchedule.extend({
   /**
-   * Strategy
-   */
+  * Strategy
+  */
   strategy: z.literal("TWAP"),
   /**
-   * Intent
-   */
+  * Intent
+  */
   intent: z.literal("CLOSE"),
   /**
-   * Slice interval in seconds
-   */
+  * Slice interval in seconds
+  */
   sliceIntervalSec: z.number(),
   /**
-   * Number of slices planned inside the execution window
-   */
+  * Number of slices planned inside the execution window
+  */
   sliceCount: z.number().int().positive(),
   /**
-   * Bounded timing and basket-size randomization
-   */
+  * Bounded timing and basket-size randomization
+  */
   randomization: TWAPRandomization,
   /**
-   * Position UUID
-   */
+  * Position UUID
+  */
   positionId: z.uuid(),
   /**
-   * Initial exposure
-   */
+  * Initial exposure
+  */
   initialExposure: z.record(InstrumentId, SignedDecimalString)
 });
-const Schedule = z.discriminatedUnion("intent", [TWAPOpen, TWAPClose]);
+const Schedule = z.discriminatedUnion("intent", [
+  TWAPOpen,
+  TWAPClose
+]);
 
 export { Schedule, ScheduleCancelledReason, ScheduleExecutionType, ScheduleIntent, ScheduleStatus, ScheduleStrategy, TWAPClose, TWAPOpen };

package/dist/schedule/payloads.js

@@ -13,16 +13,16 @@ const TargetNotional = UnsignedDecimalString.refine((value) => /[1-9]/.test(valu
 });
 const TWAPOpenLeg = z.object({
   /**
-   * Instrument ID
-   */
+  * Instrument ID
+  */
   symbol: InstrumentId,
   /**
-   * Direction to take
-   */
+  * Direction to take
+  */
   side: Side,
   /**
-   * Share of the parent target notional allocated to this leg
-   */
+  * Share of the parent target notional allocated to this leg
+  */
   weight: AssetWeight
 });
 const TWAPOpenLegs = z.array(TWAPOpenLeg).superRefine(RefineMinimumOneSymbol).superRefine(RefineUniqueSymbols).superRefine(RefineWeightingSum);
@@ -46,60 +46,63 @@ const BaseSchedule = z.object({
 });
 const CreateTWAPOpen = BaseSchedule.safeExtend({
   /**
-   * Strategy
-   */
+  * Strategy
+  */
   strategy: z.literal("TWAP"),
   /**
-   * Intent
-   */
+  * Intent
+  */
   intent: z.literal("OPEN"),
   /**
-   * Execution type
-   */
+  * Execution type
+  */
   executionType: z.literal("MARKET"),
   /**
-   * Parent-order allocation for each leg
-   */
+  * Parent-order allocation for each leg
+  */
   legs: TWAPOpenLegs,
   /**
-   * Target notional
-   */
+  * Target notional
+  */
   targetNotional: TargetNotional,
   /**
-   * Slice interval in seconds
-   */
+  * Slice interval in seconds
+  */
   sliceIntervalSec: SliceIntervalSec,
   /**
-   * Attribution route code (client_ids.code)
-   */
+  * Attribution route code (client_ids.code)
+  */
   clientId: ClientIdCode
 });
 const CreateTWAPClose = BaseSchedule.safeExtend({
   /**
-   * Strategy
-   */
+  * Strategy
+  */
   strategy: z.literal("TWAP"),
   /**
-   * Intent
-   */
+  * Intent
+  */
   intent: z.literal("CLOSE"),
   /**
-   * Execution type
-   */
+  * Execution type
+  */
   executionType: z.literal("MARKET"),
   /**
-   * Position UUID
-   */
+  * Position UUID
+  */
   positionId: z.uuid(),
   /**
-   * Slice interval in seconds
-   */
+  * Slice interval in seconds
+  */
   sliceIntervalSec: SliceIntervalSec,
   /**
-   * Attribution route code (client_ids.code)
-   */
+  * Attribution route code (client_ids.code)
+  */
   clientId: ClientIdCode
 });
-const CreateSchedule = z.discriminatedUnion("intent", [CreateTWAPOpen, CreateTWAPClose]);
+const CreateSchedule = z.discriminatedUnion("intent", [
+  CreateTWAPOpen,
+  CreateTWAPClose
+]);
 
 export { CreateSchedule, CreateTWAPClose, CreateTWAPOpen };

package/dist/schedule/queries.js

@@ -2,7 +2,11 @@ import { z } from 'zod';
 import { normalizeArray, CursorFindParams } from '../common';
 import { Connector } from '../connector';
 
-const StatusEnum = z.enum(["ACTIVE", "COMPLETED", "CANCELLED"]);
+const StatusEnum = z.enum([
+  "ACTIVE",
+  "COMPLETED",
+  "CANCELLED"
+]);
 const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(StatusEnum));
 const ScheduleListParams = CursorFindParams.extend({
   connector: Connector.optional(),

package/dist/schedule/responses.js

@@ -2,9 +2,17 @@ import { z } from 'zod';
 import { CursorResponse } from '../common';
 import { Schedule } from './entities';
 
-const ScheduleListResponse = CursorResponse.extend({ schedules: z.array(Schedule) });
-const CreateScheduleResponse = z.object({ schedule: Schedule });
-const CancelScheduleResponse = z.object({ id: z.uuid() });
-const CancelAllSchedulesResponse = z.object({ ids: z.array(z.uuid()) });
+const ScheduleListResponse = CursorResponse.extend({
+  schedules: z.array(Schedule)
+});
+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, ScheduleListResponse };

package/dist/statistics/entities.d.ts

@@ -17,6 +17,7 @@ export declare const LeaderboardRow: z.ZodObject<{
     pearFee: z.ZodString;
     tradeFee: z.ZodString;
     totalTrades: z.ZodNumber;
+    roi: z.ZodOptional<z.ZodString>;
     xHandle: z.ZodOptional<z.ZodString>;
     xName: z.ZodOptional<z.ZodString>;
     xAvatarUrl: z.ZodOptional<z.ZodString>;

package/dist/statistics/entities.js

@@ -21,6 +21,18 @@ const LeaderboardRow = z.object({
   pearFee: z.string(),
   tradeFee: z.string(),
   totalTrades: z.number(),
+  // The plain average of this account's per-position returns, as a ratio: "0.25" is +25%.
+  // Every position is weighted equally, so a small winner counts as much as a large one —
+  // this is a measure of the trader's decisions, not of the dollars those decisions moved.
+  //
+  // Each position is measured against the size it opened with. An open position contributes
+  // its unrealized PnL, a closed one what it realized after fees.
+  //
+  // Absent when the board could measure none of the account's positions — never "0", which
+  // would claim a break-even trader. An account reaches the board with nothing measurable
+  // when its only activity in scope is a fill on a position opened before startDate, or when
+  // none of its positions recorded an opening size.
+  roi: z.string().optional(),
   // The trader's linked X account. Absent for an account whose owner has connected no X
   // account, and absent for an anonymous caller: the board itself is public, but pairing a
   // real name with a wallet address and a PnL for the open internet is a wider promise than

package/dist/statistics/queries.d.ts

@@ -53,6 +53,7 @@ export declare const LeaderboardSortBy: z.ZodEnum<{
     trades: "trades";
     volume: "volume";
     totalNetPnl: "totalNetPnl";
+    roi: "roi";
 }>;
 export type LeaderboardSortBy = z.infer<typeof LeaderboardSortBy>;
 export declare const LEADERBOARD_MAX_LIMIT = 200;
@@ -70,6 +71,7 @@ export declare const LeaderboardQueryParams: z.ZodObject<{
         trades: "trades";
         volume: "volume";
         totalNetPnl: "totalNetPnl";
+        roi: "roi";
     }>>;
     startDate: z.ZodOptional<z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodTransform<Date, number>>>;
     endDate: z.ZodOptional<z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodTransform<Date, number>>>;

package/dist/statistics/queries.js

@@ -4,7 +4,11 @@ import { Connector } from '../connector';
 
 const VolumeStatisticsQueryParams = z.object({
   connector: Connector,
-  resolution: z.enum(["1h", "4h", "24h"]),
+  resolution: z.enum([
+    "1h",
+    "4h",
+    "24h"
+  ]),
   startDate: z.coerce.date().optional(),
   endDate: z.coerce.date().default(() => /* @__PURE__ */ new Date()),
   // Per-client scope; absent serves the global series. The literal 'other'
@@ -15,7 +19,11 @@ const VolumeStatisticsQueryParams = z.object({
 });
 const OiStatisticsQueryParams = z.object({
   connector: Connector,
-  resolution: z.enum(["1h", "4h", "24h"]),
+  resolution: z.enum([
+    "1h",
+    "4h",
+    "24h"
+  ]),
   startDate: z.coerce.date().optional(),
   endDate: z.coerce.date().default(() => /* @__PURE__ */ new Date()),
   // Per-client scope; absent serves the global series. The literal 'other'
@@ -30,7 +38,12 @@ const StatisticsTotalsQueryParams = z.object({
   // selects the unattributed (NULL) bucket; an unknown code returns zero totals.
   clientId: z.string().trim().min(1).optional()
 });
-const LeaderboardSortBy = z.enum(["trades", "totalNetPnl", "volume"]);
+const LeaderboardSortBy = z.enum([
+  "trades",
+  "totalNetPnl",
+  "volume",
+  "roi"
+]);
 const LEADERBOARD_MAX_LIMIT = 200;
 const UnixSeconds = z.coerce.number().int().min(0).transform((seconds) => new Date(seconds * 1e3));
 const ConnectorArray = z.preprocess((arg) => normalizeArray(arg), z.array(Connector));

package/dist/statistics/responses.d.ts

@@ -18,6 +18,7 @@ export declare const LeaderboardResponse: z.ZodObject<{
         pearFee: z.ZodString;
         tradeFee: z.ZodString;
         totalTrades: z.ZodNumber;
+        roi: z.ZodOptional<z.ZodString>;
         xHandle: z.ZodOptional<z.ZodString>;
         xName: z.ZodOptional<z.ZodString>;
         xAvatarUrl: z.ZodOptional<z.ZodString>;

package/dist/sync/payloads.js

@@ -7,7 +7,9 @@ import { PositionClosedReason, PositionStatus, PositionOrigin } from '../positio
 
 const ExchangeFillId = z.string().trim().min(1, "Exchange fill ID must be non-empty");
 const MsTimestamp = z.number().int().positive().describe("Unix timestamp in milliseconds");
-const LiquidationMark = z.object({ mark: UnsignedDecimalString }).nullable();
+const LiquidationMark = z.object({
+  mark: UnsignedDecimalString
+}).nullable();
 const OriginalFillRef = z.object({
   exchangeFillId: ExchangeFillId,
   quantity: UnsignedDecimalString
@@ -52,11 +54,13 @@ const ReconcileReplacementExternalFill = z.object({
   builderFee: UnsignedDecimalString,
   liquidation: LiquidationMark
 });
-const ConfirmFillsRequest = z.record(z.uuid().describe("Position ID"), z.tuple([ConfirmableExternalFill]).rest(ConfirmableExternalFill)).superRefine(RefineMinimumOneKeyValuePair);
-const ReconcileFillsRequest = z.record(
-  z.string().trim().min(1, "CLOID must be non-empty"),
-  z.tuple([ReconcileReplacementExternalFill, ReconcileReplacementExternalFill]).rest(ReconcileReplacementExternalFill)
-).superRefine(RefineMinimumOneKeyValuePair);
+const ConfirmFillsRequest = z.record(z.uuid().describe("Position ID"), z.tuple([
+  ConfirmableExternalFill
+]).rest(ConfirmableExternalFill)).superRefine(RefineMinimumOneKeyValuePair);
+const ReconcileFillsRequest = z.record(z.string().trim().min(1, "CLOID must be non-empty"), z.tuple([
+  ReconcileReplacementExternalFill,
+  ReconcileReplacementExternalFill
+]).rest(ReconcileReplacementExternalFill)).superRefine(RefineMinimumOneKeyValuePair);
 const SyncFillsSinceRequest = z.object({
   overlapMs: z.number().int().positive()
 });
@@ -105,17 +109,11 @@ const ApplicablePosition = z.object({
 });
 const WATERMARK_FUTURE_SKEW_MS = 3e5;
 const SyncMeta = z.object({
-  externalMaxTs: z.number().int().nonnegative().refine(
-    (timestamp) => timestamp <= Date.now() + WATERMARK_FUTURE_SKEW_MS,
-    "externalMaxTs must not be ahead of server time"
-  ).nullable().describe("watermark advance source")
+  externalMaxTs: z.number().int().nonnegative().refine((timestamp) => timestamp <= Date.now() + WATERMARK_FUTURE_SKEW_MS, "externalMaxTs must not be ahead of server time").nullable().describe("watermark advance source")
 });
 const CreateApplicablesMeta = SyncMeta.extend({
   firstSyncStartedAt: z.number().int().nonnegative().optional().describe("backend-issued timestamp returned before the first fill-history fetch"),
-  newestFillTs: z.number().int().nonnegative().refine(
-    (timestamp) => timestamp <= Date.now() + WATERMARK_FUTURE_SKEW_MS,
-    "newestFillTs must not be ahead of server time"
-  ).optional().describe("raw newest fetched fill \u2014 settle-gate source, never trim-advanced")
+  newestFillTs: z.number().int().nonnegative().refine((timestamp) => timestamp <= Date.now() + WATERMARK_FUTURE_SKEW_MS, "newestFillTs must not be ahead of server time").optional().describe("raw newest fetched fill \u2014 settle-gate source, never trim-advanced")
 });
 const CreateApplicablesRequest = z.object({
   applicables: z.array(ApplicablePosition),
@@ -128,9 +126,7 @@ const FundingPaymentEntry = z.object({
   instrumentId: InstrumentId,
   fundingRate: OptionallySignedDecimalString.describe("applied funding rate, optionally signed"),
   notional: OptionallySignedDecimalString.describe("funding amount in USD notional, optionally signed"),
-  fundingPerUnit: OptionallySignedDecimalString.describe(
-    "signed funding per 1 unit of size (notional / szi); attribution coefficient"
-  ),
+  fundingPerUnit: OptionallySignedDecimalString.describe("signed funding per 1 unit of size (notional / szi); attribution coefficient"),
   timestamp: MsTimestamp
 });
 const CreateFundingPaymentsRequest = z.object({

package/dist/tca/entities.js

@@ -1,6 +1,9 @@
 import { z } from 'zod';
 
 const TcaMetricStatus = z.literal("FINAL");
-const TcaTimingGranularity = z.enum(["BATCH", "LEG"]);
+const TcaTimingGranularity = z.enum([
+  "BATCH",
+  "LEG"
+]);
 
 export { TcaMetricStatus, TcaTimingGranularity };

package/dist/tca/responses.js

@@ -14,7 +14,10 @@ const TcaBenchmarkResponse = z.object({
   legIndex: z.number(),
   connector: Connector,
   symbol: z.string(),
-  side: z.enum(["BUY", "SELL"]),
+  side: z.enum([
+    "BUY",
+    "SELL"
+  ]),
   decisionPrice: optionalNumeric,
   arrivalMid: optionalNumeric,
   arrivalBid: optionalNumeric,