@pear-protocol/hyperliquid-sdk 0.0.1

package/README.md

@@ -0,0 +1,265 @@
+# Pear Hyperliquid SDK
+
+React SDK for Pear Protocol Hyperliquid API integration.
+
+## Installation
+
+```bash
+npm install @pear-protocol/hyperliquid-sdk
+# or
+yarn add @pear-protocol/hyperliquid-sdk
+```
+
+## Usage
+
+### React Provider Setup
+
+The SDK provides a React Provider that manages both the client and migration functions:
+
+```typescript
+import React from 'react';
+import { PearHyperliquidProvider } from '@pear-protocol/hyperliquid-sdk';
+
+function App() {
+  return (
+    <PearHyperliquidProvider
+      config={{
+        baseUrl: 'https://api.hyperliquid.xyz',
+        timeout: 30000, // optional
+        headers: { // optional
+          'Authorization': 'Bearer your-token'
+        }
+      }}
+    >
+      <YourAppComponents />
+    </PearHyperliquidProvider>
+  );
+}
+```
+
+### Using Migration Functions
+
+The migration functions are provided directly by the PearHyperliquidProvider and accessed via hooks:
+
+```typescript
+import React from 'react';
+import { useMigrationHooks, SyncTradeHistoryDto } from '@pear-protocol/hyperliquid-sdk';
+
+function TradeHistoryMigration() {
+  const { tradeHistory } = useMigrationHooks();
+
+  const handleMigration = async () => {
+    const payload: SyncTradeHistoryDto = {
+      address: '0x1234567890abcdef1234567890abcdef12345678',
+      data: {
+        tradeHistoryId: 'trade-123',
+        positionId: 'pos-123',
+        address: '0x1234...abcd',
+        externalFeePaid: 0.001,
+        builderFeePaid: 0.0005,
+        realizedPnl: 0.15,
+        totalValue: 20000,
+        entryRatio: 0.5,
+        exitRatio: 0.5,
+        leverage: 2,
+        longAssets: [],
+        shortAssets: [],
+        createdAt: '2024-01-01T00:00:00.000Z'
+      }
+    };
+
+    try {
+      await tradeHistory.sync(payload);
+    } catch (error) {
+      console.error('Migration failed:', error);
+    }
+  };
+
+  return (
+    <div>
+      <button onClick={handleMigration} disabled={tradeHistory.loading}>
+        {tradeHistory.loading ? 'Migrating...' : 'Migrate Trade History'}
+      </button>
+      
+      {tradeHistory.error && (
+        <div style={{ color: 'red' }}>
+          Error: {tradeHistory.error.message}
+        </div>
+      )}
+      
+      {tradeHistory.data && (
+        <div style={{ color: 'green' }}>
+          Success: {tradeHistory.data.message}
+          <br />
+          Position ID: {tradeHistory.data.positionId}
+          <br />
+          Trade History ID: {tradeHistory.data.tradeHistoryId}
+        </div>
+      )}
+      
+      <button onClick={tradeHistory.reset}>Reset</button>
+    </div>
+  );
+}
+```
+
+### Using Generic SDK Functions
+
+For general SDK operations, use the generic hook:
+
+```typescript
+import React from 'react';
+import { usePearHyperliquid } from '@pear-protocol/hyperliquid-sdk';
+
+function MyComponent() {
+  const { client, setAuthToken, setHeaders, getBaseUrl } = usePearHyperliquid();
+
+  const handleAuth = () => {
+    setAuthToken('new-bearer-token');
+  };
+
+  return (
+    <div>
+      <p>Base URL: {getBaseUrl()}</p>
+      <button onClick={handleAuth}>Set Auth Token</button>
+    </div>
+  );
+}
+```
+
+### Direct Client Usage (Legacy)
+
+You can still use the client directly without the provider:
+
+```typescript
+import { PearHyperliquidClient, SyncTradeHistoryDto } from '@pear-protocol/hyperliquid-sdk';
+
+const client = new PearHyperliquidClient({ baseUrl: 'https://api.hyperliquid.xyz' });
+
+const syncData: SyncTradeHistoryDto = {
+  address: '0x1234567890abcdef1234567890abcdef12345678',
+  data: {
+    tradeHistoryId: 'trade-123',
+    positionId: 'pos-123',
+    address: '0x1234...abcd',
+    externalFeePaid: 0.001,
+    builderFeePaid: 0.0005,
+    realizedPnl: 0.15,
+    totalValue: 20000,
+    entryRatio: 0.5,
+    exitRatio: 0.5,
+    leverage: 2,
+    longAssets: [],
+    shortAssets: [],
+    createdAt: '2024-01-01T00:00:00.000Z'
+  }
+};
+
+try {
+  const response = await client.syncTradeHistory(syncData);
+  console.log('Sync successful:', response.data);
+} catch (error) {
+  console.error('Sync failed:', error);
+}
+```
+
+## API Reference
+
+### PearHyperliquidProvider
+
+React Provider component that manages both the SDK client and migration functions.
+
+**Props:**
+- `config: PearHyperliquidConfig` - Configuration object
+  - `baseUrl: string` - Base URL for the API (required)
+  - `timeout?: number` - Request timeout in milliseconds (default: 30000)
+  - `headers?: Record<string, string>` - Additional headers
+
+**Provides:**
+- Client instance for API calls
+- Migration functions with state management
+- Context for all child hooks
+
+### Hooks
+
+#### useMigrationHooks()
+Returns migration-specific operations managed by the provider. Must be used within `PearHyperliquidProvider`.
+
+**Returns:**
+- `tradeHistory.sync: (payload: SyncTradeHistoryDto) => Promise<ApiResponse<SyncTradeHistoryResponseDto>>`
+- `tradeHistory.loading: boolean` - Loading state
+- `tradeHistory.error: ApiErrorResponse | null` - Error state  
+- `tradeHistory.data: SyncTradeHistoryResponseDto | null` - Response data
+- `tradeHistory.reset: () => void` - Reset state
+
+**Future migration operations:**
+- `openPositions.sync()` - Will be added for open positions migration
+- `closedPositions.sync()` - Will be added for closed positions migration
+
+#### usePearHyperliquid()
+Returns generic SDK utilities. Must be used within `PearHyperliquidProvider`.
+
+**Returns:**
+- `client: PearHyperliquidClient` - Direct client access
+- `setAuthToken: (token: string) => void` - Set authorization header
+- `setHeaders: (headers: Record<string, string>) => void` - Update request headers
+- `getBaseUrl: () => string` - Get configured base URL
+
+#### usePearHyperliquidClient()
+Lower-level hook that returns the client instance directly.
+
+### PearHyperliquidClient
+
+#### Methods
+- `getBaseUrl(): string` - Get the configured base URL
+- `setHeaders(headers: Record<string, string>): void` - Update request headers
+- `setAuthToken(token: string): void` - Set authorization header
+- `syncTradeHistory(payload: SyncTradeHistoryDto): Promise<ApiResponse<SyncTradeHistoryResponseDto>>` - Sync trade history
+
+## Types
+
+All TypeScript types are exported from the main package:
+- `PearHyperliquidConfig`
+- `ApiResponse<T>`
+- `ApiErrorResponse`
+- `TradeHistoryAssetDataDto`
+- `TradeHistoryDataDto`
+- `SyncTradeHistoryDto`
+- `SyncTradeHistoryResponseDto`
+
+## Error Handling
+
+The SDK provides structured error handling with the `ApiErrorResponse` type:
+
+```typescript
+interface ApiErrorResponse {
+  statusCode: number;
+  message: string;
+  error?: string;
+}
+```
+
+Errors are automatically intercepted and transformed into this format.
+
+## Architecture
+
+The SDK follows a provider-centric architecture where:
+
+1. **PearHyperliquidProvider** manages both the client instance and migration functions
+2. **Migration functions** are provided as part of the provider context with built-in state management
+3. **Hooks** access the provider context and must be used within the provider
+4. **State management** for migrations (loading, error, data) is handled automatically by the provider
+
+This ensures that migration functions are properly integrated with React's component lifecycle and state management.
+
+## Future Migration Operations
+
+The provider is designed to be extensible. Future versions will include additional migration functions:
+- Open positions migration
+- Closed positions migration  
+- Account data migration
+- Additional migration utilities
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,43 @@
+import { PearHyperliquidConfig, ApiResponse, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncOpenOrderDto, SyncOpenOrderResponseDto } from './types';
+/**
+ * Main SDK client for Pear Protocol Hyperliquid API integration
+ */
+export declare class PearHyperliquidClient {
+    private httpClient;
+    private baseUrl;
+    constructor(config: PearHyperliquidConfig);
+    /**
+     * Get the configured base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Update request headers
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Set authorization header
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Make a generic HTTP request
+     */
+    private makeRequest;
+    /**
+     * Sync trade history data from old database structure to new database format
+     * @param payload - Trade history data with user address
+     * @returns Promise with sync result
+     */
+    syncTradeHistory(payload: SyncTradeHistoryDto): Promise<ApiResponse<SyncTradeHistoryResponseDto>>;
+    /**
+     * Sync open positions data from old database structure to new database format
+     * @param payload - Open positions data with user address
+     * @returns Promise with sync result
+     */
+    syncOpenPositions(payload: SyncOpenPositionDto): Promise<ApiResponse<SyncOpenPositionResponseDto>>;
+    /**
+     * Sync open orders data from old database structure to new database format
+     * @param payload - Open orders data with user address
+     * @returns Promise with sync result
+     */
+    syncOpenOrders(payload: SyncOpenOrderDto): Promise<ApiResponse<SyncOpenOrderResponseDto>>;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useAddress } from './useAddress';
+export { useTradeHistories, useOpenPositions, useOpenOrders, useAccountSummary } from './useTrading';

package/dist/hooks/useAddress.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook to manage address (login/logout functionality)
+ */
+export declare const useAddress: () => {
+    address: string | null;
+    setAddress: (address: string | null) => void;
+    clearAddress: () => void;
+    isLoggedIn: boolean;
+};

package/dist/hooks/useTrading.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Hook to access trade histories
+ */
+export declare const useTradeHistories: () => import("..").PaginatedTradeHistoryResponseDto | null;
+/**
+ * Hook to access open positions
+ */
+export declare const useOpenPositions: () => import("..").OpenPositionDto[] | null;
+/**
+ * Hook to access open orders
+ */
+export declare const useOpenOrders: () => import("..").OpenLimitOrderDto[] | null;
+/**
+ * Hook to access account summary
+ */
+export declare const useAccountSummary: () => import("..").AccountSummaryResponseDto | null;