@orderly.network/vaults 2.6.1-alpha.0

package/README.md

@@ -0,0 +1,277 @@
+# Vaults Package
+
+## Request API
+
+This package provides a robust and feature-rich HTTP client for making API requests. The optimized request module includes advanced features like retry logic, timeout handling, request/response interceptors, and comprehensive error handling.
+
+### Features
+
+- 🔄 **Automatic Retry Logic**: Configurable retry attempts with exponential backoff
+- ⏱️ **Timeout Support**: Request timeout with automatic cancellation
+- 🔧 **Request/Response Interceptors**: Middleware for request and response processing
+- 🎯 **Type Safety**: Full TypeScript support with generic types
+- 🚨 **Enhanced Error Handling**: Structured error responses with codes and status
+- 📦 **Multiple HTTP Methods**: GET, POST, PUT, DELETE, PATCH convenience methods
+- 🔗 **Base URL Support**: Automatic URL construction with base URL
+- 📊 **Response Validation**: Configurable status code validation
+- 🔍 **Smart Query Parameters**: Automatic query string building with undefined value filtering
+
+### Basic Usage
+
+All methods now use a **single configuration object** for maximum simplicity and consistency:
+
+```typescript
+import { request, RequestClient } from "./api/request";
+import client from "./api/request";
+
+// Simple GET request
+const user = await client.get<User>("/api/users/1");
+
+// GET with query parameters
+const users = await client.get<User[]>("/api/users", {
+  params: { page: 1, limit: 10, status: "active" },
+});
+
+// POST with data
+const newUser = await client.post<User>("/api/users", {
+  data: { name: "John Doe", email: "john@example.com" },
+});
+
+// PUT with data and custom config
+const updatedUser = await client.put<User>("/api/users/1", {
+  data: { name: "Jane Doe" },
+  timeout: 8000,
+  retry: 1,
+});
+
+// DELETE with config
+await client.delete("/api/users/1", {
+  timeout: 5000,
+});
+```
+
+### Complete Configuration Example
+
+```typescript
+// All options in a single, clear object
+const data = await client.get<UserData[]>("/api/users", {
+  baseURL: "https://api.example.com",
+  params: {
+    page: 1,
+    limit: 10,
+    status: "active",
+    search: undefined, // Automatically filtered out
+  },
+  timeout: 10000,
+  retry: 2,
+  headers: {
+    Authorization: "Bearer token123",
+  },
+});
+```
+
+### Configuration Object Structure
+
+The simplified API uses a single configuration object with these fields:
+
+```typescript
+interface SimpleRequestConfig {
+  // Request data (for POST/PUT/PATCH)
+  data?: any;
+
+  // Query parameters (flexible - accepts any object with string keys)
+  params?: Record<string, unknown>;
+
+  // API configuration
+  baseURL?: string;
+  timeout?: number;
+  retry?: number;
+  retryDelay?: number;
+
+  // Standard fetch options
+  headers?: HeadersInit;
+  signal?: AbortSignal;
+  cache?: RequestCache;
+  credentials?: RequestCredentials;
+  // ... other standard RequestInit options
+}
+```
+
+### Parameter Handling
+
+The `params` field is flexible and can accept:
+
+- Simple key-value objects: `{ page: 1, status: 'active' }`
+- Typed parameter objects: `{ vault_id: 'abc', time_range: '30d' }`
+- Mixed types: `{ id: 123, enabled: true, name: 'test' }`
+- Objects will be automatically flattened and undefined values filtered out
+
+**Always use the `params` field for query parameters** - never mix them with config options!
+
+### Advanced Configuration
+
+```typescript
+import { RequestClient } from "./api/request";
+
+// Create a custom client instance
+const apiClient = new RequestClient();
+
+// Configure default settings
+const data = await apiClient.request<ApiResponse>("/api/data", {
+  timeout: 5000, // 5 second timeout
+  retry: 2, // Retry 2 times on failure
+  retryDelay: 2000, // Wait 2 seconds between retries
+  baseURL: "https://api.example.com",
+  headers: {
+    Authorization: "Bearer token123",
+    "X-Custom-Header": "value",
+  },
+});
+```
+
+### Request Interceptors
+
+```typescript
+// Add authentication header automatically
+apiClient.addRequestInterceptor(async (config) => {
+  const token = await getAuthToken();
+  return {
+    ...config,
+    headers: {
+      ...config.headers,
+      Authorization: `Bearer ${token}`,
+    },
+  };
+});
+
+// Add request logging
+apiClient.addRequestInterceptor((config) => {
+  console.log("Making request to:", config.url);
+  return config;
+});
+```
+
+### Response Interceptors
+
+```typescript
+// Transform response data
+apiClient.addResponseInterceptor(async (response, data) => {
+  // Add timestamp to all responses
+  return {
+    ...data,
+    timestamp: Date.now(),
+  };
+});
+
+// Handle global error logging
+apiClient.addResponseInterceptor(async (response, data) => {
+  if (!response.ok) {
+    console.error("Request failed:", response.status, data);
+  }
+  return data;
+});
+```
+
+### Error Handling
+
+```typescript
+import { VaultsApiError } from "./api/request";
+
+try {
+  const data = await client.get("/api/data");
+} catch (error) {
+  if (error instanceof VaultsApiError) {
+    console.error("API Error:", {
+      message: error.message,
+      code: error.code,
+      status: error.status,
+      response: error.response,
+    });
+  } else {
+    console.error("Network or other error:", error);
+  }
+}
+```
+
+### Custom Validation
+
+```typescript
+// Only accept 2xx status codes
+const data = await client.request("/api/data", {
+  validateStatus: (status) => status >= 200 && status < 300,
+});
+
+// Accept 404 as valid (useful for optional resources)
+const optionalData = await client.request("/api/optional-data", {
+  validateStatus: (status) => (status >= 200 && status < 300) || status === 404,
+});
+```
+
+### Working with Different Response Formats
+
+The client automatically handles the standard `{ success: boolean, data: any, message?: string }` format used by Orderly APIs, but also works with any JSON response format.
+
+```typescript
+// Standard Orderly API response
+interface StandardResponse {
+  success: boolean;
+  data: UserData;
+  message?: string;
+}
+
+// The client will automatically extract the 'data' field
+const userData = await client.get<UserData>("/api/users/1");
+
+// For non-standard responses, the full response is returned
+const customResponse = await client.get<CustomApiResponse>("/api/custom");
+```
+
+### Integration with Existing Hooks
+
+This request client is designed to work seamlessly with the existing `useApiUrl` hook:
+
+```typescript
+import client from "../api/request";
+import { useApiUrl } from "../hooks/useApiUrl";
+
+function useVaultsData() {
+  const apiUrl = useApiUrl();
+
+  const fetchVaults = async () => {
+    return client.get("/api/vaults", {
+      baseURL: apiUrl,
+    });
+  };
+
+  return { fetchVaults };
+}
+```
+
+### Migration from Old Request Function
+
+The new implementation is backward compatible. If you were using:
+
+```typescript
+// Old usage
+const data = await request<UserData>("/api/users", { method: "GET" });
+```
+
+This will continue to work exactly as before. For new code, consider using the enhanced features:
+
+```typescript
+// New enhanced usage
+const data = await client.get<UserData>("/api/users", {
+  timeout: 5000,
+  retry: 2,
+});
+```
+
+### Best Practices
+
+1. **Use the default client** for simple requests
+2. **Create custom client instances** for different APIs or when you need different default configurations
+3. **Add interceptors** at the application level for cross-cutting concerns like authentication
+4. **Handle VaultsApiError specifically** for better error UX
+5. **Set appropriate timeouts** based on your API's expected response times
+6. **Use retry sparingly** - only for idempotent operations
+7. **Leverage TypeScript** for better development experience and runtime safety

package/dist/index.d.mts

@@ -0,0 +1,274 @@
+import * as react from 'react';
+import { FC } from 'react';
+import * as zustand from 'zustand';
+
+interface VaultSupportedChain {
+    chain_id: string;
+    chain_name: string;
+}
+type VaultTimeRange = "24h" | "7d" | "30d" | "all_time";
+interface VaultInfo {
+    vault_id: string;
+    vault_address: string;
+    vault_type: string;
+    performance_fee_rate: number;
+    supported_chains: VaultSupportedChain[];
+    tvl: number;
+    apr30_d: number;
+    vault_lifetime_net_pnl: number;
+    lp_counts: number;
+    total_main_shares: number;
+    est_main_share_price: number;
+    gate_threshold_pct: number;
+    gate_triggered: boolean;
+    lock_duration: number;
+    broker_id: string;
+    "30d_apr": number;
+    "30d_apy": number;
+}
+interface VaultLpPerformance {
+    time_range: VaultTimeRange;
+    tvl_max_drawdown: number;
+    incremental_net_pnl: number;
+    pnl_max_drawdown: number;
+}
+interface VaultLpInfo {
+    vault_id: string;
+    lp_nav: number;
+    lp_tvl: number;
+    total_main_shares: number;
+    available_main_shares: number;
+    potential_pnl: number;
+}
+interface VaultOperation {
+    type: OperationType;
+    vault_id: string;
+    amount_change: number;
+    created_time: string;
+    status: string;
+}
+declare enum RoleType {
+    LP = "lp",
+    SP = "sp"
+}
+declare enum OperationType {
+    DEPOSIT = "deposit",
+    WITHDRAWAL = "withdrawal"
+}
+type VaultsPageConfig = {
+    headerImage?: string | React.ReactNode;
+};
+
+type VaultsPageProps = {
+    className?: string;
+    config?: VaultsPageConfig;
+};
+declare const VaultsPage: FC<VaultsPageProps>;
+
+interface VaultInfoResponse {
+    rows: VaultInfo[];
+}
+interface VaultLpPerformanceResponse {
+    rows: VaultLpPerformance[];
+}
+interface VaultLpInfoResponse {
+    rows: VaultLpInfo[];
+}
+interface VaultPerformanceParams {
+    vault_id: string;
+    time_range?: VaultTimeRange;
+}
+interface VaultLpInfoParams {
+    vault_id: string;
+    wallet_address: string;
+}
+interface VaultOperationMessage {
+    payloadType: string;
+    nonce: string;
+    receiver: string;
+    amount: string;
+    vaultId: string;
+    token: string;
+    dexBrokerId: string;
+    chainId?: string;
+    chainType?: string;
+}
+type VaultOperationRequest = {
+    message: VaultOperationMessage;
+    signature: string;
+    userAddress: string;
+    verifyingContract: string;
+};
+/**
+ * Get vault information
+ * @param baseUrl - The base URL for the API endpoints
+ * @returns Promise<VaultInfoResponse> - Array of vault information
+ */
+declare function getVaultInfo(baseUrl: string): Promise<VaultInfoResponse>;
+/**
+ * Get vault LP performance data
+ * @param baseUrl - The base URL for the API endpoints
+ * @param params - Parameters including vault_id and time_range
+ * @returns Promise<VaultLpPerformanceResponse> - Array of vault LP performance data
+ */
+declare function getVaultLpPerformance(baseUrl: string, params: VaultPerformanceParams): Promise<VaultLpPerformanceResponse>;
+/**
+ * Get vault LP information
+ * @param baseUrl - The base URL for the API endpoints
+ * @param params - Parameters including vault_id and wallet_address
+ * @returns Promise<VaultLpInfoResponse> - Array of vault LP information
+ */
+declare function getVaultLpInfo(baseUrl: string, params: VaultLpInfoParams): Promise<VaultLpInfoResponse>;
+
+interface VaultsState {
+    baseUrl: string;
+    vaultInfo: {
+        data: VaultInfo[];
+        loading: boolean;
+        error: string | null;
+        lastUpdated: number | null;
+    };
+    vaultLpPerformance: {
+        data: Record<string, VaultLpPerformance[]>;
+        loading: boolean;
+        error: string | null;
+        lastUpdated: number | null;
+        params: VaultPerformanceParams | null;
+    };
+    vaultLpInfo: {
+        data: Record<string, VaultLpInfo[]>;
+        loading: boolean;
+        error: string | null;
+        lastUpdated: number | null;
+        params: VaultLpInfoParams | null;
+    };
+    vaultsPageConfig: VaultsPageConfig | null;
+    setBaseUrl: (baseUrl: string) => void;
+    fetchVaultInfo: (baseUrl?: string) => Promise<void>;
+    refreshVaultInfo: () => Promise<void>;
+    fetchVaultLpPerformance: (params: VaultPerformanceParams, baseUrl?: string) => Promise<void>;
+    refreshVaultLpPerformance: () => Promise<void>;
+    fetchVaultLpInfo: (params: VaultLpInfoParams, baseUrl?: string) => Promise<void>;
+    refreshVaultLpInfo: () => Promise<void>;
+    setVaultsPageConfig: (config: VaultsPageConfig) => void;
+}
+declare const useVaultsStore: zustand.UseBoundStore<zustand.StoreApi<VaultsState>>;
+declare const useVaultInfoState: () => {
+    data: VaultInfo[];
+    loading: boolean;
+    error: string | null;
+    lastUpdated: number | null;
+};
+declare const useVaultLpPerformanceState: () => {
+    data: Record<string, VaultLpPerformance[]>;
+    loading: boolean;
+    error: string | null;
+    lastUpdated: number | null;
+    params: VaultPerformanceParams | null;
+};
+declare const useVaultLpInfoState: () => {
+    data: Record<string, VaultLpInfo[]>;
+    loading: boolean;
+    error: string | null;
+    lastUpdated: number | null;
+    params: VaultLpInfoParams | null;
+};
+declare const useVaultInfoActions: () => {
+    fetchVaultInfo: (baseUrl?: string) => Promise<void>;
+    refreshVaultInfo: () => Promise<void>;
+};
+declare const useVaultLpPerformanceActions: () => {
+    fetchVaultLpPerformance: (params: VaultPerformanceParams, baseUrl?: string) => Promise<void>;
+    refreshVaultLpPerformance: () => Promise<void>;
+};
+declare const useVaultLpInfoActions: () => {
+    fetchVaultLpInfo: (params: VaultLpInfoParams, baseUrl?: string) => Promise<void>;
+    refreshVaultLpInfo: () => Promise<void>;
+};
+declare const useVaultLpPerformanceById: (vaultId: string) => VaultLpPerformance[];
+declare const useVaultLpInfoById: (vaultId: string) => VaultLpInfo[];
+declare const useVaultLpPerformanceIds: () => string[];
+declare const useVaultLpInfoIds: () => string[];
+declare const useVaultLpPerformanceArray: () => VaultLpPerformance[];
+declare const useVaultLpInfoArray: () => VaultLpInfo[];
+
+declare const AllVaultsWidget: FC;
+
+declare const AllVaultsDesktop: FC<{
+    vaults: VaultInfo[];
+}>;
+
+type VaultCardWidgetProps = {
+    vault: VaultInfo;
+};
+declare const VaultCardWidget: FC<VaultCardWidgetProps>;
+
+declare const useVaultCardScript: (vault: VaultInfo) => {
+    title: string;
+    description: string;
+    icon: string;
+    vaultInfo: VaultInfo;
+    lpInfo: {
+        deposits: string;
+        earnings: string;
+    } | {
+        deposits: number;
+        earnings: number;
+    };
+    isEVMConnected: boolean;
+    openDepositAndWithdraw: (activeTab: "deposit" | "withdraw") => void;
+    availableBalance: number;
+    openVaultWebsite: () => void;
+    isWrongNetwork: boolean;
+};
+type VaultCardScript = ReturnType<typeof useVaultCardScript>;
+
+declare const VaultCard: FC<VaultCardScript>;
+
+declare const ORDERLY_ICON = "https://oss.orderly.network/static/symbol_logo/ORDER.png";
+declare const ORDERLY_VAULT_TITLE = "Orderly OmniVault";
+declare const ORDERLY_VAULT_DESCRIPTION = "Earn passive yields effortlessly, no trading expertise required. OmniVault deploys market-making strategies, taking on liquidations, and accrue platform fees.";
+
+declare const VaultsHeaderWidget: FC;
+
+declare const useVaultsHeaderScript: () => {
+    supportVaults: VaultSupportedChain[];
+    headerImage: react.ReactNode;
+};
+type VaultsHeaderScript = ReturnType<typeof useVaultsHeaderScript>;
+
+declare const VaultsHeaderDesktop: FC<VaultsHeaderScript>;
+
+declare const VaultsIntroductionWidget: FC;
+
+declare const VaultDepositAndWithdrawWithDialogId = "VaultDepositAndWithdrawWithDialogId";
+declare const VaultDepositAndWithdrawWithSheetId = "VaultDepositAndWithdrawWithSheetId";
+type VaultDepositAndWithdrawProps = {
+    activeTab?: "deposit" | "withdraw";
+    close?: () => void;
+    vaultId: string;
+};
+declare const VaultDepositAndWithdraw: FC<VaultDepositAndWithdrawProps>;
+
+type VaultDepositWidgetProps = {
+    vaultId: string;
+};
+
+declare const VaultDepositWidget: FC<VaultDepositWidgetProps>;
+
+type VaultWithdrawWidgetProps = {
+    vaultId: string;
+};
+declare const VaultWithdrawWidget: FC<VaultWithdrawWidgetProps>;
+
+type LatestDepositWidgetProps = {
+    vaultId: string;
+};
+declare const LatestDepositWidget: FC<LatestDepositWidgetProps>;
+
+type LatestWithdrawWidgetProps = {
+    vaultId: string;
+};
+declare const LatestWithdrawWidget: FC<LatestWithdrawWidgetProps>;
+
+export { AllVaultsDesktop, AllVaultsWidget, LatestDepositWidget, type LatestDepositWidgetProps, LatestWithdrawWidget, type LatestWithdrawWidgetProps, ORDERLY_ICON, ORDERLY_VAULT_DESCRIPTION, ORDERLY_VAULT_TITLE, OperationType, RoleType, VaultCard, type VaultCardScript, VaultCardWidget, type VaultCardWidgetProps, VaultDepositAndWithdraw, type VaultDepositAndWithdrawProps, VaultDepositAndWithdrawWithDialogId, VaultDepositAndWithdrawWithSheetId, VaultDepositWidget, type VaultInfo, type VaultInfoResponse, type VaultLpInfo, type VaultLpInfoParams, type VaultLpInfoResponse, type VaultLpPerformance, type VaultLpPerformanceResponse, type VaultOperation, type VaultOperationMessage, type VaultOperationRequest, type VaultPerformanceParams, type VaultSupportedChain, type VaultTimeRange, VaultWithdrawWidget, type VaultWithdrawWidgetProps, VaultsHeaderDesktop, type VaultsHeaderScript, VaultsHeaderWidget, VaultsIntroductionWidget, VaultsPage, type VaultsPageConfig, type VaultsPageProps, getVaultInfo, getVaultLpInfo, getVaultLpPerformance, useVaultCardScript, useVaultInfoActions, useVaultInfoState, useVaultLpInfoActions, useVaultLpInfoArray, useVaultLpInfoById, useVaultLpInfoIds, useVaultLpInfoState, useVaultLpPerformanceActions, useVaultLpPerformanceArray, useVaultLpPerformanceById, useVaultLpPerformanceIds, useVaultLpPerformanceState, useVaultsHeaderScript, useVaultsStore };