@pear-protocol/types 0.0.1

package/dist/auth/entities.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const AuthenticatedUser: z.ZodObject<{
+    id: z.ZodUUID;
+    role: z.ZodEnum<{
+        basic: "basic";
+        pro: "pro";
+    }>;
+}, z.core.$strip>;
+export type AuthenticatedUser = z.infer<typeof AuthenticatedUser>;

package/dist/auth/entities.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const AuthenticatedUser = z.object({
+  id: z.uuid().describe("User UUID"),
+  role: z.enum(["basic", "pro"]).describe("User role")
+}).describe("Current authenticated user info");
+
+export { AuthenticatedUser };

package/dist/auth/index.d.ts

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

package/dist/auth/index.js

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

package/dist/auth/payloads.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const RequestNonceRequest: z.ZodObject<{
+    address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>;
+export declare const EmailRegisterRequest: z.ZodObject<{
+    email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const LinkEmailRequest: z.ZodObject<{
+    email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const LinkWalletRequest: z.ZodObject<{
+    address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    signature: z.ZodString;
+}, z.core.$strip>;
+export declare const WalletLoginRequest: z.ZodObject<{
+    method: z.ZodLiteral<"wallet">;
+    address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    signature: z.ZodString;
+}, z.core.$strip>;
+export declare const EmailLoginRequest: z.ZodObject<{
+    method: z.ZodLiteral<"email">;
+    email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const LoginRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    method: z.ZodLiteral<"wallet">;
+    address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    signature: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    method: z.ZodLiteral<"email">;
+    email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
+    password: z.ZodString;
+}, z.core.$strip>], "method">;
+export declare const RefreshTokenRequest: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+export declare const LogoutRequest: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+export type RequestNonceRequest = z.infer<typeof RequestNonceRequest>;
+export type WalletLoginRequest = z.infer<typeof WalletLoginRequest>;
+export type EmailRegisterRequest = z.infer<typeof EmailRegisterRequest>;
+export type LinkEmailRequest = z.infer<typeof LinkEmailRequest>;
+export type LinkWalletRequest = z.infer<typeof LinkWalletRequest>;
+export type EmailLoginRequest = z.infer<typeof EmailLoginRequest>;
+export type LoginRequest = z.infer<typeof LoginRequest>;
+export type RefreshTokenRequest = z.infer<typeof RefreshTokenRequest>;
+export type LogoutRequest = z.infer<typeof LogoutRequest>;

package/dist/auth/payloads.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+
+const EthereumAddress = z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address").transform((val) => val.toLowerCase()).describe("Ethereum wallet address (0x-prefixed, 40 hex chars, lowercase)");
+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 RequestNonceRequest = z.object({
+  address: EthereumAddress
+}).describe("Request a nonce for wallet authentication");
+const EmailRegisterRequest = z.object({
+  email: Email,
+  password: Password
+}).describe("Email registration request");
+const LinkEmailRequest = z.object({
+  email: Email,
+  password: Password
+}).describe("Link email/password credentials to the authenticated account");
+const LinkWalletRequest = z.object({
+  address: EthereumAddress,
+  signature: z.string().min(1, "Signature is required").describe("Signature of the nonce message")
+}).describe("Link wallet credentials to the authenticated account");
+const WalletLoginRequest = z.object({
+  method: z.literal("wallet").describe('Must be "wallet" for wallet authentication'),
+  address: EthereumAddress,
+  signature: z.string().min(1, "Signature is required").describe("Signature of the nonce message")
+}).describe("Wallet-based authentication using nonce signature");
+const EmailLoginRequest = z.object({
+  method: z.literal("email").describe('Must be "email" for email authentication'),
+  email: Email,
+  password: Password
+}).describe("Email-based authentication using email and password");
+const LoginRequest = z.discriminatedUnion("method", [WalletLoginRequest, EmailLoginRequest]);
+const RefreshTokenRequest = z.object({
+  refreshToken: z.string().min(1, "Refresh token is required").describe("Refresh token")
+}).describe("Refresh token request");
+const LogoutRequest = z.object({
+  refreshToken: z.string().min(1, "Refresh token is required").describe("Refresh token to revoke")
+}).describe("Logout and revoke refresh token");
+
+export { EmailLoginRequest, EmailRegisterRequest, LinkEmailRequest, LinkWalletRequest, LoginRequest, LogoutRequest, RefreshTokenRequest, RequestNonceRequest, WalletLoginRequest };

package/dist/auth/response.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const LoginResponse: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodUUID;
+        role: z.ZodEnum<{
+            basic: "basic";
+            pro: "pro";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const RefreshTokenResponse: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    tokenType: z.ZodLiteral<"Bearer">;
+    expiresIn: z.ZodNumber;
+}, z.core.$strip>;
+export declare const RefreshSessionResponse: z.ZodObject<{}, z.core.$strip>;
+export declare const LogoutResponse: z.ZodObject<{}, z.core.$strip>;
+export declare const RegisterResponse: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodUUID;
+        role: z.ZodEnum<{
+            basic: "basic";
+            pro: "pro";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const LinkResponse: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodUUID;
+        role: z.ZodEnum<{
+            basic: "basic";
+            pro: "pro";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const RequestNonceResponse: z.ZodObject<{
+    nonce: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MeResponse: z.ZodObject<{
+    id: z.ZodUUID;
+    role: z.ZodEnum<{
+        basic: "basic";
+        pro: "pro";
+    }>;
+}, z.core.$strip>;
+export type RequestNonceResponse = z.infer<typeof RequestNonceResponse>;
+export type LoginResponse = z.infer<typeof LoginResponse>;
+export type RefreshSessionResponse = z.infer<typeof RefreshSessionResponse>;
+export type RefreshTokenResponse = z.infer<typeof RefreshTokenResponse>;
+export type LogoutResponse = z.infer<typeof LogoutResponse>;
+export type RegisterResponse = z.infer<typeof RegisterResponse>;
+export type LinkResponse = z.infer<typeof LinkResponse>;
+export type MeResponse = z.infer<typeof MeResponse>;

package/dist/auth/response.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { AuthenticatedUser } from './entities';
+
+const LoginResponse = z.object({ user: AuthenticatedUser }).describe("Successful login response");
+const RefreshTokenResponse = z.object({
+  accessToken: z.string().describe("New JWT access token"),
+  refreshToken: z.string().describe("New JWT refresh token"),
+  tokenType: z.literal("Bearer").describe('Token type (always "Bearer")'),
+  expiresIn: z.number().int().positive().describe("Access token expiry time in seconds")
+}).describe("Successful token refresh response");
+const RefreshSessionResponse = z.object({}).describe("Successful session refresh response");
+const LogoutResponse = z.object({}).describe("Successful logout response");
+const RegisterResponse = LoginResponse.describe("Successful registration response");
+const LinkResponse = LoginResponse.describe("Successful link response");
+const RequestNonceResponse = z.object({
+  nonce: z.string().describe("Nonce to sign with wallet"),
+  expiresAt: z.number().int().positive().describe("Unix timestamp when nonce expires")
+}).describe("Nonce response for wallet authentication");
+const MeResponse = AuthenticatedUser.describe("Current authenticated user info");
+
+export { LinkResponse, LoginResponse, LogoutResponse, MeResponse, RefreshSessionResponse, RefreshTokenResponse, RegisterResponse, RequestNonceResponse };

package/dist/bundle.d.ts

@@ -0,0 +1,17 @@
+export * from './auth';
+export * from './common/trade-legs';
+export * from './connector';
+export * from './execution';
+export * from './fill';
+export * from './funding';
+export * from './instrument';
+export * from './instrument-precision';
+export * from './misc';
+export * from './order';
+export * from './position';
+export * from './price';
+export * from './schedule';
+export * from './trade';
+export * from './trade-accounts';
+export * from './trigger';
+export * from './users';

package/dist/bundle.js

@@ -0,0 +1,17 @@
+export * from './auth';
+export * from './common/trade-legs';
+export * from './connector';
+export * from './execution';
+export * from './fill';
+export * from './funding';
+export * from './instrument';
+export * from './instrument-precision';
+export * from './misc';
+export * from './order';
+export * from './position';
+export * from './price';
+export * from './schedule';
+export * from './trade';
+export * from './trade-accounts';
+export * from './trigger';
+export * from './users';

package/dist/common/array.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Normalize an array of values to a string array.
+ * Using the zod preprocess function this allows us
+ * to correctly type the input instead of getting
+ * the 'unknown' type.
+ *
+ * @param val - The value to normalize.
+ * @returns The normalized value.
+ */
+export declare function normalizeArray<TInput>(val: TInput): (TInput & any[]) | string[] | undefined;

package/dist/common/array.js

@@ -0,0 +1,10 @@
+function normalizeArray(val) {
+  if (!val) return void 0;
+  if (Array.isArray(val)) return val;
+  if (typeof val === "string") {
+    return val.includes(",") ? val.split(",").map((s) => s.trim()) : [val];
+  }
+  return [String(val)];
+}
+
+export { normalizeArray };

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from './array';
+export * from './request';
+export * from './response';

package/dist/common/index.js

@@ -0,0 +1,3 @@
+export * from './array';
+export * from './request';
+export * from './response';

package/dist/common/refinement.d.ts

@@ -0,0 +1,20 @@
+import z from 'zod';
+export declare const RefineMinimumOneSymbol: <T extends {
+    symbol: string;
+}[]>(basket: T, ctx: z.RefinementCtx) => void;
+export declare const RefineMinimumTwoSymbols: <T extends {
+    symbol: string;
+}[]>(basket: T, ctx: z.RefinementCtx) => void;
+export declare const RefineTwoUniqueSymbols: <T extends {
+    symbol_a: string;
+    symbol_b: string;
+}>(pair: T, ctx: z.RefinementCtx) => void;
+export declare const RefineUniqueSymbols: <T extends {
+    symbol: string;
+}[]>(basket: T, ctx: z.RefinementCtx) => void;
+export declare const RefineWeightingSum: <T extends {
+    weight: number;
+}[]>(basket: T, ctx: z.RefinementCtx) => void;
+export declare const RefineMinimumOneBuyOneSell: <T extends {
+    side: "BUY" | "SELL";
+}[]>(basket: T, ctx: z.RefinementCtx) => void;

package/dist/common/refinement.js

@@ -0,0 +1,60 @@
+import 'zod';
+
+const RefineMinimumOneSymbol = (basket, ctx) => {
+  if (basket.length < 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: "At least one symbol is required."
+    });
+  }
+};
+const RefineMinimumTwoSymbols = (basket, ctx) => {
+  if (basket.length < 2) {
+    ctx.addIssue({
+      code: "custom",
+      message: "At least two symbols are required."
+    });
+  }
+};
+const RefineTwoUniqueSymbols = (pair, ctx) => {
+  if (pair.symbol_a === pair.symbol_b) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Symbols cannot be the same."
+    });
+  }
+};
+const RefineUniqueSymbols = (basket, ctx) => {
+  const symbols = basket.map((item) => item.symbol);
+  const uniqueSymbols = new Set(symbols);
+  if (symbols.length !== uniqueSymbols.size) {
+    const duplicates = symbols.filter((symbol, index) => symbols.indexOf(symbol) !== index);
+    ctx.addIssue({
+      code: "custom",
+      message: `Duplicate symbols found: ${[...new Set(duplicates)].join(", ")}`,
+      path: ["basket"]
+    });
+  }
+};
+const RefineWeightingSum = (basket, ctx) => {
+  const totalWeight = basket.reduce((acc, curr) => acc + curr.weight, 0);
+  if (totalWeight !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: `The sum of weights must be exactly 1, but got ${totalWeight}`,
+      path: ["basket"]
+    });
+  }
+};
+const RefineMinimumOneBuyOneSell = (basket, ctx) => {
+  const buyCount = basket.filter((item) => item.side === "BUY").length;
+  const sellCount = basket.filter((item) => item.side === "SELL").length;
+  if (buyCount < 1 || sellCount < 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: "At least one BUY and one SELL are required."
+    });
+  }
+};
+
+export { RefineMinimumOneBuyOneSell, RefineMinimumOneSymbol, RefineMinimumTwoSymbols, RefineTwoUniqueSymbols, RefineUniqueSymbols, RefineWeightingSum };

package/dist/common/request.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const CursorFindParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PaginationFindParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+}, z.core.$strip>;
+export type CursorFindParams = z.output<typeof CursorFindParams>;
+export type PaginationFindParams = z.output<typeof PaginationFindParams>;

package/dist/common/request.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+const CursorFindParams = z.object({
+  /**
+   * The maximum number of items to retrieve.
+   */
+  limit: z.coerce.number().int().positive().max(100).optional().default(20),
+  /**
+   * Opaque pagination cursor returned by the API.
+   */
+  cursor: z.string().optional()
+});
+const PaginationFindParams = z.object({
+  /**
+   * The maximum number of items to retrieve.
+   */
+  limit: z.coerce.number().int().positive().max(100).optional().default(20),
+  /**
+   * The number of items to skip before retrieving the returned items.
+   */
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+
+export { CursorFindParams, PaginationFindParams };

package/dist/common/response.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const PaginatedResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type PaginatedResponse = z.output<typeof PaginatedResponse>;
+export declare const CursorResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+}, z.core.$strip>;
+export type CursorResponse = z.output<typeof CursorResponse>;

package/dist/common/response.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+
+const PaginatedResponse = z.object({
+  /**
+   * The maximum number of items retrieved.
+   */
+  limit: z.number(),
+  /**
+   * The number of items to skip before retrieving the returned items.
+   */
+  offset: z.number(),
+  /**
+   * The total number of items.
+   */
+  count: z.number()
+});
+const CursorResponse = z.object({
+  /**
+   * The maximum number of items retrieved.
+   */
+  limit: z.number(),
+  /**
+   * The cursor to use for pagination.
+   */
+  nextCursor: z.string().or(z.undefined())
+});
+
+export { CursorResponse, PaginatedResponse };

package/dist/common/schema.d.ts

@@ -0,0 +1,8 @@
+import z from 'zod';
+export declare const UnsignedDecimalString: z.ZodString;
+export declare const SignedDecimalString: z.ZodString;
+export declare const Leverage: z.ZodInt;
+export declare const Side: z.ZodEnum<{
+    BUY: "BUY";
+    SELL: "SELL";
+}>;

package/dist/common/schema.js

@@ -0,0 +1,10 @@
+import z from 'zod';
+
+const UnsignedDecimalString = z.string().regex(/^\d+(\.\d+)?$/, "Must be a valid decimal string");
+const SignedDecimalString = z.string().regex(/^-?\d+(\.\d+)?$/, "Must be a valid decimal string");
+const Leverage = z.int({ message: "Leverage must be an integer" }).positive({ message: "Leverage must be greater than 0" }).max(100, { message: "Leverage must be less than 100" });
+const Side = z.enum(["BUY", "SELL"], {
+  message: "Side must be either BUY or SELL"
+});
+
+export { Leverage, Side, SignedDecimalString, UnsignedDecimalString };

package/dist/common/trade-legs.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+declare const TradeLegMode: z.ZodEnum<{
+    QUANTITY: "QUANTITY";
+    USD: "USD";
+}>;
+export type TradeLegMode = z.infer<typeof TradeLegMode>;
+export declare const TradeLeg: z.ZodObject<{
+    symbol: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    mode: z.ZodEnum<{
+        QUANTITY: "QUANTITY";
+        USD: "USD";
+    }>;
+    amount: z.ZodString;
+    reduceOnly: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const TradeLegPostOnly: z.ZodObject<{
+    symbol: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    mode: z.ZodEnum<{
+        QUANTITY: "QUANTITY";
+        USD: "USD";
+    }>;
+    amount: z.ZodString;
+}, z.core.$strip>;
+export type TradeLeg = z.infer<typeof TradeLeg>;
+export type TradeLegPostOnly = z.infer<typeof TradeLegPostOnly>;
+export {};

package/dist/common/trade-legs.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { InstrumentId } from '../instrument';
+import { UnsignedDecimalString, Side } from './schema';
+
+const TradeLegMode = z.enum(["QUANTITY", "USD"]);
+const TradeLeg = z.object({
+  /**
+   * Instrument ID
+   */
+  symbol: InstrumentId,
+  /**
+   * Side
+   */
+  side: Side,
+  /**
+   * Mode to interpret the amount
+   */
+  mode: TradeLegMode,
+  /**
+   * Quantity or USD amount
+   */
+  amount: UnsignedDecimalString,
+  /**
+   * Reduce only flag
+   */
+  reduceOnly: z.boolean()
+});
+const TradeLegPostOnly = TradeLeg.omit({ reduceOnly: true });
+
+export { TradeLeg, TradeLegPostOnly };

package/dist/connector/index.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const Connector: z.ZodEnum<{
+    hyperliquid: "hyperliquid";
+    binanceusdm: "binanceusdm";
+    bybit: "bybit";
+    okx: "okx";
+}>;
+export type Connector = z.infer<typeof Connector>;

package/dist/connector/index.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+const Connector = z.enum(["hyperliquid", "binanceusdm", "bybit", "okx"]);
+
+export { Connector };