@pear-protocol/types 2.11.0 → 2.12.0

package/dist/auth/payloads.d.ts

@@ -13,7 +13,7 @@ export declare const LinkEmailRequest: z.ZodObject<{
 export declare const LinkWalletRequest: z.ZodObject<{
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
-    nonce: z.ZodOptional<z.ZodString>;
+    nonce: z.ZodString;
 }, z.core.$strip>;
 export declare const StartXLinkRequest: z.ZodObject<{
     returnTo: z.ZodOptional<z.ZodString>;
@@ -34,7 +34,7 @@ export declare const WalletLoginRequest: z.ZodObject<{
     method: z.ZodLiteral<"wallet">;
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
-    nonce: z.ZodOptional<z.ZodString>;
+    nonce: z.ZodString;
     accessCode: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const EmailLoginRequest: z.ZodObject<{
@@ -61,7 +61,7 @@ export declare const LoginRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     method: z.ZodLiteral<"wallet">;
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
-    nonce: z.ZodOptional<z.ZodString>;
+    nonce: z.ZodString;
     accessCode: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"email">;

package/dist/auth/payloads.js

@@ -4,7 +4,7 @@ const EthereumAddress = z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereu
 const Email = z.email("Invalid email address").transform((val) => val.toLowerCase()).describe("Email address (lowercase)");
 const Password = z.string().min(8, "Password must be at least 8 characters").max(128, "Password must be at most 128 characters").describe("Password for authentication");
 const AccessCode = z.string().trim().max(64).optional().describe("Optional beta access code");
-const SignedNonce = z.string().min(1).max(128).optional().describe("Nonce of the signed challenge, as returned by the nonce endpoint");
+const SignedNonce = z.string().min(1).max(128).describe("Nonce of the signed challenge, as returned by the nonce endpoint");
 const RequestNonceRequest = z.object({
   address: EthereumAddress
 }).describe("Request a nonce for wallet authentication");

package/dist/baskets/saved/entities.js

@@ -4,7 +4,7 @@ import { Side, AssetWeight } from '../../common/schema';
 import { InstrumentId } from '../../instrument';
 
 const SavedBasketLeg = z.object({
-  // PHASE-1 LEG ID: mirrors `symbol` today; required in phase 3 when `symbol` becomes the ticker.
+  // SYMBOL-MIGRATION switch-to-id: mirrors `symbol` today; becomes required once requests always carry `id`.
   id: InstrumentId.optional().describe("Connector-native instrument id"),
   symbol: InstrumentId,
   side: Side,

package/dist/bundle.d.ts

@@ -4,6 +4,7 @@ export * from './baskets/saved';
 export * from './common/address';
 export * from './common/trade-legs';
 export * from './connector';
+export * from './copy';
 export * from './execution';
 export * from './fee';
 export * from './fill';
@@ -27,6 +28,7 @@ export * from './sync';
 export * from './tca';
 export * from './trade';
 export * from './trade-accounts';
+export * from './traders';
 export * from './trigger';
 export * from './triggers';
 export * from './users';

package/dist/bundle.js

@@ -4,6 +4,7 @@ export * from './baskets/saved';
 export * from './common/address';
 export * from './common/trade-legs';
 export * from './connector';
+export * from './copy';
 export * from './execution';
 export * from './fee';
 export * from './fill';
@@ -27,6 +28,7 @@ export * from './sync';
 export * from './tca';
 export * from './trade';
 export * from './trade-accounts';
+export * from './traders';
 export * from './trigger';
 export * from './triggers';
 export * from './users';

package/dist/common/refinement.d.ts

@@ -1,7 +1,7 @@
 import z from 'zod';
 /**
- * PHASE-1 LEG ID WARNING: these refinements key on `symbol` only. Re-key them on
- * `id ?? symbol` before clients start sending `id` (phase 2).
+ * SYMBOL-MIGRATION switch-to-id: these refinements key on `symbol` only. Re-key them on
+ * `id ?? symbol` before clients start sending `id` (the ticker track's external switch to `id`).
  */
 export declare const RefineMinimumOneSymbol: <T extends {
     symbol: string;
@@ -16,7 +16,7 @@ export declare const RefineTwoUniqueSymbols: <T extends {
 export declare const RefineUniqueSymbols: <T extends {
     symbol: string;
 }[]>(basket: T, ctx: z.RefinementCtx) => void;
-/** PHASE-1 LEG ID guard: a request's `id` must name the same instrument as `symbol`. Delete in phase 3. */
+/** SYMBOL-MIGRATION drop-symbol: a request's `id` must name the same instrument as `symbol`. Delete when `symbol` leaves the request. */
 export declare const RefineLegIdMatchesSymbol: <T extends {
     id?: string;
     symbol: string;

package/dist/common/trade-legs.js

@@ -8,7 +8,7 @@ const TradeLegMode = z.enum([
   "USD"
 ]);
 const TradeLegShape = z.object({
-  /** PHASE-1 LEG ID: mirrors `symbol` today; required in phase 3 when `symbol` becomes the ticker. */
+  /** SYMBOL-MIGRATION switch-to-id: mirrors `symbol` today; becomes required once requests always carry `id`. */
   id: InstrumentId.optional(),
   /**
   * Instrument ID

package/dist/copy/entities.d.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+export declare const CopySubscriptionStatus: z.ZodEnum<{
+    ACTIVE: "ACTIVE";
+    ENDED: "ENDED";
+}>;
+export type CopySubscriptionStatus = z.infer<typeof CopySubscriptionStatus>;
+/**
+ * How a subscription is sized.
+ *
+ * A tagged union with one member. The tag is the point: a second sizing mode becomes another variant
+ * rather than a breaking change to a field every client already reads.
+ */
+export declare const CopySizing: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"LEADER_EQUITY_FRACTION">;
+}, z.core.$strip>], "mode">;
+export type CopySizing = z.infer<typeof CopySizing>;
+export declare const CopySubscription: z.ZodObject<{
+    id: z.ZodUUID;
+    leaderTradeAccountId: z.ZodUUID;
+    followerTradeAccountId: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    status: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        ENDED: "ENDED";
+    }>;
+    sizing: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"LEADER_EQUITY_FRACTION">;
+    }, z.core.$strip>], "mode">;
+    createdAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CopySubscription = z.infer<typeof CopySubscription>;
+export declare const CopyActivityOutcome: z.ZodEnum<{
+    COPIED: "COPIED";
+    PARTIAL: "PARTIAL";
+    SKIPPED: "SKIPPED";
+    FAILED: "FAILED";
+}>;
+export type CopyActivityOutcome = z.infer<typeof CopyActivityOutcome>;
+export declare const CopyActivityState: z.ZodEnum<{
+    RECORDED: "RECORDED";
+    DISPATCHED: "DISPATCHED";
+    SETTLED: "SETTLED";
+}>;
+export type CopyActivityState = z.infer<typeof CopyActivityState>;
+/** One actual fill-derived change on the follower account. */
+export declare const CopyActivityLeg: z.ZodObject<{
+    symbol: z.ZodString;
+    targetQuantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    deltaQuantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+}, z.core.$strip>;
+export type CopyActivityLeg = z.infer<typeof CopyActivityLeg>;
+export declare const CopySkipReason: z.ZodEnum<{
+    SUBSCRIPTION_NOT_ACTIVE: "SUBSCRIPTION_NOT_ACTIVE";
+    POSITION_EXCLUDED: "POSITION_EXCLUDED";
+    INCLUDED_IN_JOIN: "INCLUDED_IN_JOIN";
+    VENUE_MISMATCH: "VENUE_MISMATCH";
+    BELOW_VENUE_MINIMUM: "BELOW_VENUE_MINIMUM";
+    PAIR_ALREADY_ENTERED: "PAIR_ALREADY_ENTERED";
+    ENTRY_EXPIRED: "ENTRY_EXPIRED";
+    FOLLOWER_LEG_ABSENT: "FOLLOWER_LEG_ABSENT";
+    LEADER_LEG_REOPENED: "LEADER_LEG_REOPENED";
+    NO_FOLLOWER_DELTA: "NO_FOLLOWER_DELTA";
+    LEADER_EQUITY_UNREADABLE: "LEADER_EQUITY_UNREADABLE";
+    FOLLOWER_EQUITY_UNREADABLE: "FOLLOWER_EQUITY_UNREADABLE";
+    PRICE_UNAVAILABLE: "PRICE_UNAVAILABLE";
+    LEVERAGE_NOT_APPLIED: "LEVERAGE_NOT_APPLIED";
+}>;
+export type CopySkipReason = z.infer<typeof CopySkipReason>;
+export declare const CopyLeaderAction: z.ZodEnum<{
+    OPEN: "OPEN";
+    ADJUST: "ADJUST";
+    CLOSE: "CLOSE";
+    REVERSE: "REVERSE";
+}>;
+export type CopyLeaderAction = z.infer<typeof CopyLeaderAction>;
+/** Leader execution provenance; these resources are never installed on the follower. */
+export declare const CopyExecutionSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    origin: z.ZodLiteral<"DIRECT">;
+}, z.core.$strip>, z.ZodObject<{
+    origin: z.ZodLiteral<"SCHEDULE">;
+    scheduleId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    origin: z.ZodLiteral<"TRIGGER">;
+    triggerId: z.ZodString;
+    triggerIntent: z.ZodEnum<{
+        OPEN: "OPEN";
+        ADJUST: "ADJUST";
+        CLOSE: "CLOSE";
+    }>;
+    bracketType: z.ZodOptional<z.ZodString>;
+    ladderId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    origin: z.ZodLiteral<"AUTO_REBALANCE">;
+    configId: z.ZodString;
+}, z.core.$strip>], "origin">;
+export type CopyExecutionSource = z.infer<typeof CopyExecutionSource>;
+/**
+ * One leader action, and what it meant for this follower.
+ *
+ * Every leader action writes one of these, including the ones that produced no order at all — at a
+ * small size most actions resolve to nothing, and those are precisely the ones the follower most
+ * needs to see.
+ */
+export declare const CopyActivity: z.ZodObject<{
+    id: z.ZodUUID;
+    leaderAction: z.ZodEnum<{
+        OPEN: "OPEN";
+        ADJUST: "ADJUST";
+        CLOSE: "CLOSE";
+        REVERSE: "REVERSE";
+    }>;
+    executionSource: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        origin: z.ZodLiteral<"DIRECT">;
+    }, z.core.$strip>, z.ZodObject<{
+        origin: z.ZodLiteral<"SCHEDULE">;
+        scheduleId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        origin: z.ZodLiteral<"TRIGGER">;
+        triggerId: z.ZodString;
+        triggerIntent: z.ZodEnum<{
+            OPEN: "OPEN";
+            ADJUST: "ADJUST";
+            CLOSE: "CLOSE";
+        }>;
+        bracketType: z.ZodOptional<z.ZodString>;
+        ladderId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        origin: z.ZodLiteral<"AUTO_REBALANCE">;
+        configId: z.ZodString;
+    }, z.core.$strip>], "origin">>;
+    state: z.ZodEnum<{
+        RECORDED: "RECORDED";
+        DISPATCHED: "DISPATCHED";
+        SETTLED: "SETTLED";
+    }>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        COPIED: "COPIED";
+        PARTIAL: "PARTIAL";
+        SKIPPED: "SKIPPED";
+        FAILED: "FAILED";
+    }>>;
+    skipReason: z.ZodOptional<z.ZodEnum<{
+        SUBSCRIPTION_NOT_ACTIVE: "SUBSCRIPTION_NOT_ACTIVE";
+        POSITION_EXCLUDED: "POSITION_EXCLUDED";
+        INCLUDED_IN_JOIN: "INCLUDED_IN_JOIN";
+        VENUE_MISMATCH: "VENUE_MISMATCH";
+        BELOW_VENUE_MINIMUM: "BELOW_VENUE_MINIMUM";
+        PAIR_ALREADY_ENTERED: "PAIR_ALREADY_ENTERED";
+        ENTRY_EXPIRED: "ENTRY_EXPIRED";
+        FOLLOWER_LEG_ABSENT: "FOLLOWER_LEG_ABSENT";
+        LEADER_LEG_REOPENED: "LEADER_LEG_REOPENED";
+        NO_FOLLOWER_DELTA: "NO_FOLLOWER_DELTA";
+        LEADER_EQUITY_UNREADABLE: "LEADER_EQUITY_UNREADABLE";
+        FOLLOWER_EQUITY_UNREADABLE: "FOLLOWER_EQUITY_UNREADABLE";
+        PRICE_UNAVAILABLE: "PRICE_UNAVAILABLE";
+        LEVERAGE_NOT_APPLIED: "LEVERAGE_NOT_APPLIED";
+    }>>;
+    failureReason: z.ZodOptional<z.ZodString>;
+    followerLegs: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        targetQuantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+        deltaQuantity: z.ZodPipe<z.ZodString, z.ZodTransform<`-${string}` | `+${string}`, string>>;
+    }, z.core.$strip>>;
+    leaderEquityFraction: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type CopyActivity = z.infer<typeof CopyActivity>;
+/** A current follower account with only its owner's publishable X identity. */
+export declare const CopyFollower: z.ZodObject<{
+    tradeAccountId: z.ZodUUID;
+    status: z.ZodLiteral<"ACTIVE">;
+    followedAt: z.ZodString;
+    xUserId: z.ZodOptional<z.ZodString>;
+    xHandle: z.ZodOptional<z.ZodString>;
+    xName: z.ZodOptional<z.ZodString>;
+    xAvatarUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CopyFollower = z.output<typeof CopyFollower>;

package/dist/copy/entities.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { SignedDecimalString } from '../common/schema';
+import { Connector } from '../connector';
+import { InstrumentId } from '../instrument';
+
+const CopySubscriptionStatus = z.enum([
+  "ACTIVE",
+  "ENDED"
+]);
+const CopySizing = z.discriminatedUnion("mode", [
+  z.object({
+    /**
+    * Entry is the leader's own notional-over-equity fraction applied to the follower's equity, taken
+    * at the moment of entry. There is nothing for the follower to size.
+    */
+    mode: z.literal("LEADER_EQUITY_FRACTION")
+  })
+]);
+const CopySubscription = z.object({
+  id: z.uuid(),
+  leaderTradeAccountId: z.uuid().describe("The account being copied"),
+  followerTradeAccountId: z.uuid().describe("The account copies land in"),
+  connector: Connector,
+  status: CopySubscriptionStatus,
+  sizing: CopySizing,
+  createdAt: z.string().describe("ISO 8601"),
+  endedAt: z.string().optional().describe("ISO 8601; set once the follower unsubscribed")
+});
+const CopyActivityOutcome = z.enum([
+  "COPIED",
+  "PARTIAL",
+  "SKIPPED",
+  "FAILED"
+]);
+const CopyActivityState = z.enum([
+  "RECORDED",
+  "DISPATCHED",
+  "SETTLED"
+]);
+const CopyActivityLeg = z.object({
+  symbol: InstrumentId,
+  targetQuantity: SignedDecimalString,
+  deltaQuantity: SignedDecimalString
+});
+const CopySkipReason = z.enum([
+  "SUBSCRIPTION_NOT_ACTIVE",
+  "POSITION_EXCLUDED",
+  "INCLUDED_IN_JOIN",
+  "VENUE_MISMATCH",
+  "BELOW_VENUE_MINIMUM",
+  "PAIR_ALREADY_ENTERED",
+  "ENTRY_EXPIRED",
+  "FOLLOWER_LEG_ABSENT",
+  "LEADER_LEG_REOPENED",
+  "NO_FOLLOWER_DELTA",
+  "LEADER_EQUITY_UNREADABLE",
+  "FOLLOWER_EQUITY_UNREADABLE",
+  "PRICE_UNAVAILABLE",
+  "LEVERAGE_NOT_APPLIED"
+]);
+const CopyLeaderAction = z.enum([
+  "OPEN",
+  "ADJUST",
+  "CLOSE",
+  "REVERSE"
+]);
+const CopyExecutionSource = z.discriminatedUnion("origin", [
+  z.object({
+    origin: z.literal("DIRECT")
+  }),
+  z.object({
+    origin: z.literal("SCHEDULE"),
+    scheduleId: z.string()
+  }),
+  z.object({
+    origin: z.literal("TRIGGER"),
+    triggerId: z.string(),
+    triggerIntent: z.enum([
+      "OPEN",
+      "ADJUST",
+      "CLOSE"
+    ]),
+    bracketType: z.string().optional(),
+    ladderId: z.string().optional()
+  }),
+  z.object({
+    origin: z.literal("AUTO_REBALANCE"),
+    configId: z.string()
+  })
+]);
+const CopyActivity = z.object({
+  id: z.uuid(),
+  leaderAction: CopyLeaderAction.describe("What the leader did"),
+  executionSource: CopyExecutionSource.optional().describe("Leader source; absent for admission position joins"),
+  state: CopyActivityState,
+  outcome: CopyActivityOutcome.optional().describe("Absent until dispatch work settles"),
+  skipReason: CopySkipReason.optional().describe("Why nothing was placed; set when the outcome is SKIPPED"),
+  failureReason: z.string().optional().describe("Why execution stopped; set when the outcome is FAILED or PARTIAL"),
+  followerLegs: z.array(CopyActivityLeg).describe("Actual fills received by the follower"),
+  leaderEquityFraction: z.string().optional().describe("The leader position notional over their equity at that moment; absent when unvaluable"),
+  createdAt: z.string().describe("ISO 8601")
+});
+const CopyFollower = z.object({
+  tradeAccountId: z.uuid(),
+  status: z.literal("ACTIVE"),
+  followedAt: z.string().describe("ISO 8601 subscription creation time"),
+  xUserId: z.string().optional(),
+  xHandle: z.string().optional(),
+  xName: z.string().optional(),
+  xAvatarUrl: z.string().optional()
+});
+
+export { CopyActivity, CopyActivityLeg, CopyActivityOutcome, CopyActivityState, CopyExecutionSource, CopyFollower, CopyLeaderAction, CopySizing, CopySkipReason, CopySubscription, CopySubscriptionStatus };

package/dist/copy/index.d.ts

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

package/dist/copy/index.js

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

package/dist/copy/payloads.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/**
+ * Start copying a leader into the account selected by the x-trade-account-id header.
+ *
+ * There is no size to set. Entry is the leader's own equity fraction applied to the follower's
+ * equity. Existing eligible positions are attempted by default; set syncExistingPositions to false
+ * to start without copying them.
+ */
+export declare const CreateCopySubscription: z.ZodObject<{
+    leaderTradeAccountId: z.ZodUUID;
+    syncExistingPositions: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateCopySubscriptionInput = z.input<typeof CreateCopySubscription>;
+export type CreateCopySubscription = z.output<typeof CreateCopySubscription>;

package/dist/copy/payloads.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const CreateCopySubscription = z.object({
+  leaderTradeAccountId: z.uuid().describe("The account to copy"),
+  syncExistingPositions: z.boolean().default(true).describe("Copy existing leader positions when subscribing")
+});
+
+export { CreateCopySubscription };

package/dist/copy/queries.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const CopyActivityListParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type CopyActivityListParamsInput = z.input<typeof CopyActivityListParams>;
+export type CopyActivityListParams = z.output<typeof CopyActivityListParams>;
+/** Fill timestamps use an inclusive start and exclusive end; counts remain current/lifetime. */
+export declare const CopyStatsParams: z.ZodObject<{
+    startDate: z.ZodOptional<z.ZodCoercedDate<Date>>;
+    endDate: z.ZodOptional<z.ZodCoercedDate<Date>>;
+}, z.core.$strip>;
+export type CopyStatsParamsInput = z.input<typeof CopyStatsParams>;
+export type CopyStatsParams = z.output<typeof CopyStatsParams>;

package/dist/copy/queries.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+const CopyActivityListParams = z.object({
+  limit: z.coerce.number().int().min(1).max(200).default(50)
+});
+const CopyStatsParams = z.object({
+  startDate: z.coerce.date().optional(),
+  endDate: z.coerce.date().optional()
+}).refine((params) => !params.startDate || !params.endDate || params.startDate < params.endDate, {
+  message: "startDate must be before endDate",
+  path: [
+    "startDate"
+  ]
+});
+
+export { CopyActivityListParams, CopyStatsParams };