@0xmonaco/types 0.4.2 → 0.5.1

package/dist/validation/common.js

@@ -0,0 +1,196 @@
+/**
+ * Common Validation Utilities
+ *
+ * Shared utilities for runtime validation across all SDK modules.
+ * These utilities work with any Zod schema and provide consistent
+ * error handling throughout the SDK.
+ */
+/**
+ * Validation error class for user-friendly error messages.
+ *
+ * Wraps Zod validation errors to provide better error formatting and
+ * structured error access for API consumers. This error is thrown when
+ * validation fails on any SDK parameters.
+ *
+ * **Features:**
+ * - Human-readable error message with field paths
+ * - Access to raw Zod issues for detailed error handling
+ * - Structured error object via `getErrors()` method
+ *
+ * **Example Usage:**
+ * ```typescript
+ * import { validate, PlaceLimitOrderSchema } from '@0xmonaco/types';
+ *
+ * try {
+ *   const validated = validate(PlaceLimitOrderSchema, {
+ *     tradingPairId: "invalid-uuid",
+ *     side: "BUY",
+ *     quantity: "-10", // Invalid: negative
+ *     price: "100"
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     // Human-readable message
+ *     console.log(error.message);
+ *     // "Validation failed:
+ *     //   - tradingPairId: Invalid uuid
+ *     //   - quantity: Number must be greater than 0"
+ *
+ *     // Structured errors for form validation
+ *     const errors = error.getErrors();
+ *     console.log(errors);
+ *     // {
+ *     //   "tradingPairId": "Invalid uuid",
+ *     //   "quantity": "Number must be greater than 0"
+ *     // }
+ *
+ *     // Raw Zod issues for advanced handling
+ *     console.log(error.issues);
+ *     // [{ path: ["tradingPairId"], message: "Invalid uuid", ... }, ...]
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link validate} - Helper function that throws ValidationError
+ */
+export class ValidationError extends Error {
+    /**
+     * Creates a new ValidationError from a Zod validation error.
+     *
+     * Automatically formats all validation issues into a human-readable
+     * message and stores the raw issues for programmatic access.
+     *
+     * @param zodError - The Zod validation error to wrap
+     *
+     * @example
+     * ```typescript
+     * const result = schema.safeParse(data);
+     * if (!result.success) {
+     *   throw new ValidationError(result.error);
+     * }
+     * ```
+     */
+    constructor(zodError) {
+        const messages = zodError.issues.map((issue) => {
+            const path = issue.path.join(".");
+            return `${path ? `${path}: ` : ""}${issue.message}`;
+        });
+        super(`Validation failed:\n  - ${messages.join("\n  - ")}`);
+        this.name = "ValidationError";
+        this.issues = zodError.issues;
+    }
+    /**
+     * Get validation errors as a structured object for easy field-level error display.
+     *
+     * Converts the array of Zod issues into a simple key-value object where
+     * keys are field paths (dot-notation) and values are error messages.
+     * Root-level errors (no path) are stored under the "root" key.
+     *
+     * **Use Cases:**
+     * - Form validation (map errors to input fields)
+     * - API error responses (structured JSON)
+     * - Error aggregation and reporting
+     *
+     * @returns Object mapping field paths to error messages
+     *
+     * @example
+     * ```typescript
+     * // Single field error
+     * error.getErrors();
+     * // { "price": "Number must be greater than 0" }
+     *
+     * // Multiple field errors
+     * error.getErrors();
+     * // {
+     * //   "tradingPairId": "Invalid uuid",
+     * //   "quantity": "Required",
+     * //   "options.timeInForce": "Invalid enum value"
+     * // }
+     *
+     * // Root-level error (no specific field)
+     * error.getErrors();
+     * // { "root": "At least one field is required" }
+     *
+     * // Use in React form
+     * const errors = validationError.getErrors();
+     * <input error={errors.price} />
+     * ```
+     */
+    getErrors() {
+        const errors = {};
+        for (const issue of this.issues) {
+            const path = issue.path.join(".");
+            errors[path || "root"] = issue.message;
+        }
+        return errors;
+    }
+}
+/**
+ * Validates data against a Zod schema and throws user-friendly errors on failure.
+ *
+ * This is a convenience wrapper around Zod's `safeParse` that automatically
+ * throws a {@link ValidationError} with formatted error messages when validation fails.
+ *
+ * **When to Use:**
+ * - Validating user input before API calls
+ * - Runtime type checking for dynamic data
+ * - Ensuring data integrity before processing
+ *
+ * **Error Handling:**
+ * On validation failure, throws {@link ValidationError} which provides:
+ * - Human-readable error message
+ * - Structured errors via `getErrors()`
+ * - Raw Zod issues for advanced handling
+ *
+ * @template T - The expected type after validation
+ * @param schema - Zod schema to validate against
+ * @param data - Data to validate (unknown type for safety)
+ * @returns Validated and typed data
+ * @throws {@link ValidationError} When validation fails
+ *
+ * @example
+ * ```typescript
+ * import { validate, PlaceLimitOrderSchema } from '@0xmonaco/types';
+ *
+ * // Basic validation
+ * try {
+ *   const validatedOrder = validate(PlaceLimitOrderSchema, userInput);
+ *   // validatedOrder is now typed and guaranteed valid
+ *   await sdk.trading.placeLimitOrder(...validatedOrder);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     // Show user-friendly errors
+ *     console.error(error.message);
+ *     const fieldErrors = error.getErrors();
+ *     // Display errors next to form fields
+ *   }
+ * }
+ *
+ * // With custom error handling
+ * function safeValidate<T>(schema: z.ZodSchema<T>, data: unknown) {
+ *   try {
+ *     return { success: true, data: validate(schema, data) };
+ *   } catch (error) {
+ *     if (error instanceof ValidationError) {
+ *       return { success: false, errors: error.getErrors() };
+ *     }
+ *     throw error; // Re-throw unexpected errors
+ *   }
+ * }
+ *
+ * const result = safeValidate(PlaceLimitOrderSchema, input);
+ * if (result.success) {
+ *   // Use result.data
+ * } else {
+ *   // Handle result.errors
+ * }
+ * ```
+ */
+export function validate(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        throw new ValidationError(result.error);
+    }
+    return result.data;
+}
+//# sourceMappingURL=common.js.map

package/dist/validation/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/validation/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAOxC;;;;;;;;;;;;;;;OAeG;IACH,YAAY,QAAoB;QAC9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YAC7C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,2BAA2B,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,SAAS;QACP,MAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC;QACzC,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,UAAU,QAAQ,CAAI,MAAsB,EAAE,IAAa;IAC/D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAEtC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC"}

package/dist/validation/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validation Schemas
+ *
+ * Runtime validation using Zod for all SDK inputs.
+ * Catches errors before making API calls.
+ *
+ * **Shared Utilities:**
+ * - {@link ValidationError} - User-friendly validation error class
+ * - {@link validate} - Helper function for schema validation
+ *
+ * **Schema Modules:**
+ * - Trading schemas (orders, trading pairs)
+ * - Vault schemas (deposits, withdrawals)
+ * - Market schemas (trading pairs, candlesticks)
+ */
+export * from "./common.js";
+export * from "./trading.js";
+export * from "./vault.js";
+export * from "./market.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,cAAc,aAAa,CAAC;AAG5B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/validation/index.js

@@ -0,0 +1,22 @@
+/**
+ * Validation Schemas
+ *
+ * Runtime validation using Zod for all SDK inputs.
+ * Catches errors before making API calls.
+ *
+ * **Shared Utilities:**
+ * - {@link ValidationError} - User-friendly validation error class
+ * - {@link validate} - Helper function for schema validation
+ *
+ * **Schema Modules:**
+ * - Trading schemas (orders, trading pairs)
+ * - Vault schemas (deposits, withdrawals)
+ * - Market schemas (trading pairs, candlesticks)
+ */
+// Export validation utilities
+export * from "./common.js";
+// Export module-specific schemas
+export * from "./trading.js";
+export * from "./vault.js";
+export * from "./market.js";
+//# sourceMappingURL=index.js.map

package/dist/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,8BAA8B;AAC9B,cAAc,aAAa,CAAC;AAE5B,iCAAiC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/validation/market.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Market API Validation Schemas
+ */
+import { z } from "zod";
+/**
+ * Candlestick interval validation
+ */
+export declare const IntervalSchema: z.ZodEnum<{
+    "1m": "1m";
+    "5m": "5m";
+    "15m": "15m";
+    "1h": "1h";
+    "4h": "4h";
+    "1d": "1d";
+    "30m": "30m";
+    "1w": "1w";
+    "1M": "1M";
+}>;
+/**
+ * Timestamp validation (milliseconds since epoch)
+ *
+ * Validates that the timestamp is:
+ * - A positive integer
+ * - At least Jan 1, 2000 (catches seconds vs milliseconds errors)
+ * - Within JavaScript's safe integer range
+ * - Not unreasonably far in the future (max 1 year ahead)
+ *
+ * **Why these bounds matter:**
+ * - Prevents typos (e.g., using seconds instead of milliseconds: 1609459200 vs 1609459200000)
+ * - Catches date calculation errors (e.g., Date.now() * 1000 instead of Date.now())
+ * - Ensures timestamps won't cause precision issues in JavaScript
+ *
+ * @example
+ * ```typescript
+ * // Valid timestamps (milliseconds)
+ * validate(TimestampSchema, 1609459200000);  // Jan 1, 2021 ✅
+ * validate(TimestampSchema, Date.now());      // Current time ✅
+ * validate(TimestampSchema, Date.now() + 86400000);  // Tomorrow ✅
+ *
+ * // Invalid timestamps
+ * validate(TimestampSchema, 1609459200);      // Seconds instead of ms (Jan 19, 1970) ❌
+ * validate(TimestampSchema, Date.now() * 1000);  // Way too large ❌
+ * validate(TimestampSchema, 9999999999999999);   // Far future (year 2286) ❌
+ * validate(TimestampSchema, 100000);          // Too old (Jan 1, 1970) ❌
+ * ```
+ */
+export declare const TimestampSchema: z.ZodNumber;
+/**
+ * Get Candlesticks validation schema (by trading pair ID)
+ *
+ * Validates parameters for fetching candlestick (OHLCV) data using a trading pair UUID.
+ * Ensures that the time range is valid by checking that startTime < endTime.
+ *
+ * @example
+ * ```typescript
+ * // Valid request
+ * validate(GetCandlesticksSchema, {
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
+ *   interval: "1h",
+ *   startTime: 1609459200000,  // Jan 1, 2021
+ *   endTime: 1640995200000      // Jan 1, 2022
+ * });
+ *
+ * // Invalid: backwards time range
+ * validate(GetCandlesticksSchema, {
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
+ *   interval: "1h",
+ *   startTime: 1640995200000,  // Jan 1, 2022
+ *   endTime: 1609459200000      // Jan 1, 2021
+ * });
+ * // ValidationError: startTime must be less than endTime
+ * ```
+ */
+export declare const GetCandlesticksSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+    interval: z.ZodEnum<{
+        "1m": "1m";
+        "5m": "5m";
+        "15m": "15m";
+        "1h": "1h";
+        "4h": "4h";
+        "1d": "1d";
+        "30m": "30m";
+        "1w": "1w";
+        "1M": "1M";
+    }>;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Trading pair symbol validation
+ *
+ * Validates trading pair symbols like "BTC/USDT", "ETH/USD", etc.
+ * Symbol format: BASE/QUOTE where:
+ * - BASE and QUOTE are 1-10 alphanumeric characters
+ * - Separated by a forward slash
+ *
+ * @example
+ * ```typescript
+ * // Valid symbols
+ * validate(TradingPairSymbolSchema, "BTC/USDT");   ✅
+ * validate(TradingPairSymbolSchema, "ETH/USD");    ✅
+ * validate(TradingPairSymbolSchema, "MTK/USDCo");  ✅
+ *
+ * // Invalid symbols
+ * validate(TradingPairSymbolSchema, "BTC");        ❌ Missing quote token
+ * validate(TradingPairSymbolSchema, "BTC-USDT");   ❌ Wrong separator
+ * validate(TradingPairSymbolSchema, "/USDT");      ❌ Missing base token
+ * ```
+ */
+export declare const TradingPairSymbolSchema: z.ZodString;
+/**
+ * Get Candlesticks By Symbol validation schema
+ *
+ * Validates parameters for fetching candlestick (OHLCV) data using a trading pair symbol.
+ * This is the schema used by the actual API endpoint which accepts symbols like "BTC/USDT".
+ * Ensures that the time range is valid by checking that startTime < endTime.
+ *
+ * @example
+ * ```typescript
+ * // Valid request
+ * validate(GetCandlesticksBySymbolSchema, {
+ *   symbol: "BTC/USDT",
+ *   interval: "1h",
+ *   startTime: 1609459200000,  // Jan 1, 2021
+ *   endTime: 1640995200000      // Jan 1, 2022
+ * });
+ *
+ * // Invalid: backwards time range
+ * validate(GetCandlesticksBySymbolSchema, {
+ *   symbol: "ETH/USD",
+ *   interval: "1h",
+ *   startTime: 1640995200000,  // Jan 1, 2022
+ *   endTime: 1609459200000      // Jan 1, 2021
+ * });
+ * // ValidationError: startTime must be less than endTime
+ * ```
+ */
+export declare const GetCandlesticksBySymbolSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    interval: z.ZodEnum<{
+        "1m": "1m";
+        "5m": "5m";
+        "15m": "15m";
+        "1h": "1h";
+        "4h": "4h";
+        "1d": "1d";
+        "30m": "30m";
+        "1w": "1w";
+        "1M": "1M";
+    }>;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Get Trading Pair validation schema
+ */
+export declare const GetTradingPairSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Search Trading Pairs validation schema
+ */
+export declare const SearchTradingPairsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+//# sourceMappingURL=market.d.ts.map

package/dist/validation/market.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"market.d.ts","sourceRoot":"","sources":["../../src/validation/market.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;EAEzB,CAAC;AAkBH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,aAcxB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;iBAU9B,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,uBAAuB,aAKhC,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAUtC,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC"}

package/dist/validation/market.js

@@ -0,0 +1,185 @@
+/**
+ * Market API Validation Schemas
+ */
+import { z } from "zod";
+import { UUIDSchema } from "./trading";
+/**
+ * Candlestick interval validation
+ */
+export const IntervalSchema = z.enum(["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w", "1M"], {
+    message: 'Interval must be one of: "1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w", "1M"',
+});
+/**
+ * Maximum allowed future offset for timestamps (1 year in milliseconds)
+ *
+ * Allows queries for future dates (e.g., for scheduling or filtering) but
+ * prevents unreasonably far future dates that are likely input errors.
+ */
+const MAX_TIMESTAMP_FUTURE_OFFSET_MS = 365 * 24 * 60 * 60 * 1000; // 1 year
+/**
+ * Minimum allowed timestamp (Jan 1, 2000 in milliseconds)
+ *
+ * This catches the common error of passing timestamps in seconds instead of milliseconds.
+ * Any timestamp before year 2000 is likely an error (either seconds or invalid date).
+ */
+const MIN_TIMESTAMP_MS = 946684800000; // Jan 1, 2000 00:00:00 UTC
+/**
+ * Timestamp validation (milliseconds since epoch)
+ *
+ * Validates that the timestamp is:
+ * - A positive integer
+ * - At least Jan 1, 2000 (catches seconds vs milliseconds errors)
+ * - Within JavaScript's safe integer range
+ * - Not unreasonably far in the future (max 1 year ahead)
+ *
+ * **Why these bounds matter:**
+ * - Prevents typos (e.g., using seconds instead of milliseconds: 1609459200 vs 1609459200000)
+ * - Catches date calculation errors (e.g., Date.now() * 1000 instead of Date.now())
+ * - Ensures timestamps won't cause precision issues in JavaScript
+ *
+ * @example
+ * ```typescript
+ * // Valid timestamps (milliseconds)
+ * validate(TimestampSchema, 1609459200000);  // Jan 1, 2021 ✅
+ * validate(TimestampSchema, Date.now());      // Current time ✅
+ * validate(TimestampSchema, Date.now() + 86400000);  // Tomorrow ✅
+ *
+ * // Invalid timestamps
+ * validate(TimestampSchema, 1609459200);      // Seconds instead of ms (Jan 19, 1970) ❌
+ * validate(TimestampSchema, Date.now() * 1000);  // Way too large ❌
+ * validate(TimestampSchema, 9999999999999999);   // Far future (year 2286) ❌
+ * validate(TimestampSchema, 100000);          // Too old (Jan 1, 1970) ❌
+ * ```
+ */
+export const TimestampSchema = z
+    .number()
+    .int()
+    .positive({
+    message: "Timestamp must be a positive integer (milliseconds since epoch)",
+})
+    .min(MIN_TIMESTAMP_MS, {
+    message: "Timestamp must be at least Jan 1, 2000 (946684800000 ms). Did you pass seconds instead of milliseconds?",
+})
+    .max(Number.MAX_SAFE_INTEGER, {
+    message: "Timestamp must not exceed JavaScript's maximum safe integer",
+})
+    .refine((value) => value <= Date.now() + MAX_TIMESTAMP_FUTURE_OFFSET_MS, {
+    message: "Timestamp must not be unreasonably far in the future (max 1 year ahead)",
+});
+/**
+ * Get Candlesticks validation schema (by trading pair ID)
+ *
+ * Validates parameters for fetching candlestick (OHLCV) data using a trading pair UUID.
+ * Ensures that the time range is valid by checking that startTime < endTime.
+ *
+ * @example
+ * ```typescript
+ * // Valid request
+ * validate(GetCandlesticksSchema, {
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
+ *   interval: "1h",
+ *   startTime: 1609459200000,  // Jan 1, 2021
+ *   endTime: 1640995200000      // Jan 1, 2022
+ * });
+ *
+ * // Invalid: backwards time range
+ * validate(GetCandlesticksSchema, {
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
+ *   interval: "1h",
+ *   startTime: 1640995200000,  // Jan 1, 2022
+ *   endTime: 1609459200000      // Jan 1, 2021
+ * });
+ * // ValidationError: startTime must be less than endTime
+ * ```
+ */
+export const GetCandlesticksSchema = z
+    .object({
+    tradingPairId: UUIDSchema,
+    interval: IntervalSchema,
+    startTime: TimestampSchema,
+    endTime: TimestampSchema,
+})
+    .refine((data) => data.startTime < data.endTime, {
+    message: "startTime must be less than endTime",
+    path: ["endTime"],
+});
+/**
+ * Trading pair symbol validation
+ *
+ * Validates trading pair symbols like "BTC/USDT", "ETH/USD", etc.
+ * Symbol format: BASE/QUOTE where:
+ * - BASE and QUOTE are 1-10 alphanumeric characters
+ * - Separated by a forward slash
+ *
+ * @example
+ * ```typescript
+ * // Valid symbols
+ * validate(TradingPairSymbolSchema, "BTC/USDT");   ✅
+ * validate(TradingPairSymbolSchema, "ETH/USD");    ✅
+ * validate(TradingPairSymbolSchema, "MTK/USDCo");  ✅
+ *
+ * // Invalid symbols
+ * validate(TradingPairSymbolSchema, "BTC");        ❌ Missing quote token
+ * validate(TradingPairSymbolSchema, "BTC-USDT");   ❌ Wrong separator
+ * validate(TradingPairSymbolSchema, "/USDT");      ❌ Missing base token
+ * ```
+ */
+export const TradingPairSymbolSchema = z
+    .string()
+    .min(1, "Trading pair symbol cannot be empty")
+    .regex(/^[A-Za-z0-9]{1,10}\/[A-Za-z0-9]{1,10}$/, {
+    message: 'Trading pair symbol must be in format "BASE/QUOTE" (e.g., "BTC/USDT", "ETH/USD")',
+});
+/**
+ * Get Candlesticks By Symbol validation schema
+ *
+ * Validates parameters for fetching candlestick (OHLCV) data using a trading pair symbol.
+ * This is the schema used by the actual API endpoint which accepts symbols like "BTC/USDT".
+ * Ensures that the time range is valid by checking that startTime < endTime.
+ *
+ * @example
+ * ```typescript
+ * // Valid request
+ * validate(GetCandlesticksBySymbolSchema, {
+ *   symbol: "BTC/USDT",
+ *   interval: "1h",
+ *   startTime: 1609459200000,  // Jan 1, 2021
+ *   endTime: 1640995200000      // Jan 1, 2022
+ * });
+ *
+ * // Invalid: backwards time range
+ * validate(GetCandlesticksBySymbolSchema, {
+ *   symbol: "ETH/USD",
+ *   interval: "1h",
+ *   startTime: 1640995200000,  // Jan 1, 2022
+ *   endTime: 1609459200000      // Jan 1, 2021
+ * });
+ * // ValidationError: startTime must be less than endTime
+ * ```
+ */
+export const GetCandlesticksBySymbolSchema = z
+    .object({
+    symbol: TradingPairSymbolSchema,
+    interval: IntervalSchema,
+    startTime: TimestampSchema,
+    endTime: TimestampSchema,
+})
+    .refine((data) => data.startTime < data.endTime, {
+    message: "startTime must be less than endTime",
+    path: ["endTime"],
+});
+/**
+ * Get Trading Pair validation schema
+ */
+export const GetTradingPairSchema = z.object({
+    tradingPairId: UUIDSchema,
+});
+/**
+ * Search Trading Pairs validation schema
+ */
+export const SearchTradingPairsSchema = z.object({
+    query: z.string().min(1, "Search query cannot be empty").optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    offset: z.number().int().min(0).optional(),
+});
+//# sourceMappingURL=market.js.map

package/dist/validation/market.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"market.js","sourceRoot":"","sources":["../../src/validation/market.ts"],"names":[],"mappings":"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"}