@pear-protocol/types 2.12.0 → 2.13.0

package/dist/auth/payloads.js

@@ -25,8 +25,8 @@ const StartXLinkRequest = z.object({
   returnTo: z.string().optional().describe("Page to send the browser back to once the link finishes, normally the page the user is on. Must be on the calling origin; defaults to that origin.")
 }).describe("Start of the X account link flow");
 const SetXVisibilityRequest = z.object({
-  xHidden: z.boolean().describe("True to withhold the linked X account from the leaderboard, false to publish it. The wanted state rather than a flip, so a retry lands on the same result and two tabs cannot disagree. Named to match `xHidden` on the user profile - one name for one value.")
-}).describe("Leaderboard visibility of the X account");
+  xHidden: z.boolean().describe("True to withhold the linked X account from the leaderboard and public trader profiles, false to publish it. The wanted state rather than a flip, so a retry lands on the same result and two tabs cannot disagree. Named to match `xHidden` on the user profile - one name for one value.")
+}).describe("Visibility of the X account on the leaderboard and public trader profiles");
 const PkceValue = z.string().regex(/^[A-Za-z0-9_-]{43}$/, "Must be 43 base64url characters");
 const StartXLoginRequest = z.object({
   returnTo: z.string().optional().describe("Page to send the browser back to once the sign-in finishes, normally the page the user is on. Must be on the calling origin; defaults to that origin. Any fragment is dropped - the flow returns its ticket there."),

package/dist/auth/response.js

@@ -38,8 +38,8 @@ const StartXLinkResponse = z.object({
   authorizeUrl: z.string().describe("X authorization URL to send the browser to. Expires with the flow's state.")
 }).describe("Start of the X account link flow");
 const SetXVisibilityResponse = z.object({
-  xHidden: z.boolean().describe("The stored state, read back from the write: true when the leaderboard withholds the X account. A confirmation of what was asked for, not a value the caller could not otherwise know.")
-}).describe("Leaderboard visibility of the X account after the write");
+  xHidden: z.boolean().describe("The stored state, read back from the write: true when the leaderboard and public trader profiles withhold the X account. A confirmation of what was asked for, not a value the caller could not otherwise know.")
+}).describe("Visibility of the X account on the leaderboard and public trader profiles after the write");
 const DisconnectXResponse = z.void().describe("Successful X account disconnect response");
 const StartXLoginResponse = z.object({
   authorizeUrl: z.string().describe("X authorization URL to send the browser to. Expires with the flow's state.")

package/dist/statistics/entities.d.ts

@@ -10,6 +10,7 @@ export declare const LeaderboardRow: z.ZodObject<{
         lighter: "lighter";
         lighter_rhc: "lighter_rhc";
     }>;
+    copyingEnabled: z.ZodBoolean;
     followers: z.ZodArray<z.ZodObject<{
         tradeAccountId: z.ZodUUID;
         status: z.ZodLiteral<"ACTIVE">;

package/dist/statistics/entities.js

@@ -10,8 +10,12 @@ const LeaderboardRow = z.object({
   // address beside a real name and a PnL deanonymizes a trader for good, and an address is
   // not reversible once scraped. Neither id here is a credential — every route that takes
   // one checks ownership or role, never knowledge of the id.
+  // This guarantee applies to private routes. Shared public profiles are addressable by
+  // tradeAccountId and omit the exchange identifier, including when the owner shows X identity.
   userId: z.string(),
   connector: Connector,
+  // Current owner consent; venue support and admission availability also apply.
+  copyingEnabled: z.boolean().describe("Whether the owner allows new copy subscriptions; venue support and admission availability also apply"),
   // Followers when this board was cached, independent of the performance date range.
   followers: z.array(CopyFollower),
   followerCount: z.number().int().nonnegative(),

package/dist/statistics/responses.d.ts

@@ -11,6 +11,7 @@ export declare const LeaderboardResponse: z.ZodObject<{
             lighter: "lighter";
             lighter_rhc: "lighter_rhc";
         }>;
+        copyingEnabled: z.ZodBoolean;
         followers: z.ZodArray<z.ZodObject<{
             tradeAccountId: z.ZodUUID;
             status: z.ZodLiteral<"ACTIVE">;

package/dist/traders/public.d.ts

@@ -4,6 +4,16 @@ export declare const PublicTraderParams: z.ZodObject<{
     tradeAccountId: z.ZodUUID;
 }, z.core.$strip>;
 export type PublicTraderParams = z.output<typeof PublicTraderParams>;
+/** Public closed-history filters; refuse steps and every unsupported private option. */
+export declare const PublicTraderClosedPositionsParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>;
+export type PublicTraderClosedPositionsParamsInput = z.input<typeof PublicTraderClosedPositionsParams>;
+export type PublicTraderClosedPositionsParams = z.output<typeof PublicTraderClosedPositionsParams>;
 export declare const PublicOpenPosition: z.ZodObject<{
     status: z.ZodLiteral<"OPEN">;
     connector: z.ZodEnum<{
@@ -39,6 +49,82 @@ export declare const PublicOpenPosition: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PublicOpenPosition = z.output<typeof PublicOpenPosition>;
+/** Public closed-history fields follow the existing public vault history contract. */
+export declare const PublicClosedPosition: z.ZodObject<{
+    status: z.ZodLiteral<"CLOSED">;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    positionId: z.ZodUUID;
+    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>>;
+    openedAt: z.ZodString;
+    hasProvisionalFills: z.ZodBoolean;
+    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>>;
+        entryNotional: z.ZodString;
+        entryVwap: z.ZodOptional<z.ZodString>;
+        exitVwap: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PublicClosedPosition = z.output<typeof PublicClosedPosition>;
+/** Preserve the reader's cursor even when a page contains fewer composed positions than its limit. */
+export declare const PublicTraderClosedPositionsResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    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";
+        }>;
+        positionId: z.ZodUUID;
+        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>>;
+        openedAt: z.ZodString;
+        hasProvisionalFills: z.ZodBoolean;
+        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>>;
+            entryNotional: z.ZodString;
+            entryVwap: z.ZodOptional<z.ZodString>;
+            exitVwap: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PublicTraderClosedPositionsResponse = z.output<typeof PublicTraderClosedPositionsResponse>;
 export declare const PublicTrigger: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"MARKET">;
     id: z.ZodUUID;
@@ -2485,7 +2571,11 @@ export declare const PublicTraderResponse: z.ZodObject<{
         lighter: "lighter";
         lighter_rhc: "lighter_rhc";
     }>;
-    exchangeIdentifier: z.ZodString;
+    copyingEnabled: z.ZodBoolean;
+    xHandle: z.ZodOptional<z.ZodString>;
+    xName: z.ZodOptional<z.ZodString>;
+    xAvatarUrl: z.ZodOptional<z.ZodString>;
+    xUserId: z.ZodOptional<z.ZodString>;
     followers: z.ZodArray<z.ZodObject<{
         tradeAccountId: z.ZodUUID;
         status: z.ZodLiteral<"ACTIVE">;

package/dist/traders/public.js

@@ -1,14 +1,23 @@
 import { z } from 'zod';
+import { CursorResponse } from '../common';
 import { Connector } from '../connector';
 import { CopyFollower } from '../copy/entities';
 import { Ladder } from '../ladder/entities';
-import { OpenPosition, OpenPositionLeg } from '../position/entities';
+import { OpenPosition, OpenPositionLeg, ClosedPosition, ClosedPositionLeg } from '../position/entities';
+import { ClosedPositionListParams } from '../position/queries';
 import { TWAPOpen, TWAPClose } from '../schedule/entities';
 import { TriggerMarketOpen, TriggerMarketAdjust, TriggerMarketClose, TriggerTWAPAdjust, TriggerTWAPClose } from '../trigger/entities';
 
 const PublicTraderParams = z.object({
   tradeAccountId: z.uuid()
 });
+const PublicTraderClosedPositionsParams = z.object({
+  limit: ClosedPositionListParams.shape.limit,
+  cursor: ClosedPositionListParams.shape.cursor,
+  startDate: ClosedPositionListParams.shape.startDate,
+  endDate: ClosedPositionListParams.shape.endDate,
+  positionId: ClosedPositionListParams.shape.positionId
+}).strict();
 const PublicOpenPosition = OpenPosition.pick({
   positionId: true,
   status: true,
@@ -25,6 +34,30 @@ const PublicOpenPosition = OpenPosition.pick({
     remaining: true
   }))
 });
+const PublicClosedPosition = ClosedPosition.pick({
+  positionId: true,
+  status: true,
+  connector: true,
+  openedAt: true,
+  closedAt: true,
+  closedReason: true,
+  grossPnl: true,
+  netPnl: true,
+  hasProvisionalFills: true
+}).extend({
+  legs: z.array(ClosedPositionLeg.pick({
+    asset: true,
+    side: true,
+    entryVwap: true,
+    exitVwap: true,
+    entryNotional: true,
+    grossPnl: true,
+    netPnl: true
+  }))
+});
+const PublicTraderClosedPositionsResponse = CursorResponse.extend({
+  positions: z.array(PublicClosedPosition)
+});
 const triggerFields = {
   id: true,
   connector: true,
@@ -115,7 +148,12 @@ const PublicLadder = Ladder.pick({
 });
 const PublicTraderResponse = z.object({
   connector: Connector.describe("Exchange connector type"),
-  exchangeIdentifier: z.string().describe("User identifier on the exchange"),
+  copyingEnabled: z.boolean().describe("Whether the owner allows new copy subscriptions; venue support and admission availability also apply"),
+  // Omit X identity when the owner hides it or has not linked an account.
+  xHandle: z.string().optional().describe("Public X handle at the last authorization; absent when hidden or unlinked"),
+  xName: z.string().optional().describe("Public X display name; absent when hidden or unlinked"),
+  xAvatarUrl: z.string().optional().describe("Public X avatar URL; absent when hidden or unlinked"),
+  xUserId: z.string().optional().describe("Immutable X numeric user ID; absent when hidden or unlinked"),
   // Followers are complete; the latest-20 limit applies only to trading records.
   followers: z.array(CopyFollower),
   followerCount: z.number().int().nonnegative(),
@@ -125,4 +163,4 @@ const PublicTraderResponse = z.object({
   ladders: z.array(PublicLadder)
 });
 
-export { PublicLadder, PublicOpenPosition, PublicSchedule, PublicTraderParams, PublicTraderResponse, PublicTrigger };
+export { PublicClosedPosition, PublicLadder, PublicOpenPosition, PublicSchedule, PublicTraderClosedPositionsParams, PublicTraderClosedPositionsResponse, PublicTraderParams, PublicTraderResponse, PublicTrigger };

package/dist/users/entities.js

@@ -24,7 +24,7 @@ const UserProfile = z.object({
   // A plain boolean rather than nullable, matching `emailVerified` above: this is the
   // owner's own setting, which is known whether or not an X account is linked. With none
   // linked it describes what would happen once one is.
-  xHidden: z.boolean().describe("Whether the leaderboard withholds the linked X account")
+  xHidden: z.boolean().describe("Whether the leaderboard and public trader profiles withhold the linked X account")
 }).describe("User profile of the authenticated user");
 const BoundReferralReferee = z.object({
   status: z.literal("BOUND").describe("The referee resolves to a V3 user with a permanent binding"),

package/package.json

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