pacifica-js-sdk 1.0.0 → 1.1.0

package/README.md

@@ -1,8 +1,23 @@
+# Pacifica JS SDK (Community)
 
-# Pacifica JS SDK
+[![npm version](https://img.shields.io/npm/v/pacifica-js-sdk.svg)](https://www.npmjs.com/package/pacifica-js-sdk)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+[![Production Grade](https://img.shields.io/badge/Status-Production%20Grade-green.svg)](https://pacifica.fi)
 
-Official JavaScript/TypeScript SDK for [Pacifica](https://pacifica.fi).
-Converted from the official [Python SDK](https://github.com/pacifica-fi/python-sdk).
+Community-maintained production-ready JavaScript/TypeScript SDK for [Pacifica](https://pacifica.fi).
+Engineered for high-frequency trading bots, institutional integrations, and DeFi agents.
+
+> **Note:** This is an unofficial, community-maintained SDK. It is not affiliated with or endorsed by the Pacifica team.
+
+## Features
+
+- 🔐 **Secure Authentication**: Ed25519 signing with runtime validation for keys.
+- 🤖 **Agent Wallets**: Native support for binding and using agent wallets for automated trading.
+- 📡 **Real-time Data**: Robust WebSocket client with auto-reconnection and exponential backoff.
+- ⚡ **Full Trading Suite**: Market, Limit, Stop-Loss, and Take-Profit orders.
+- 🛡️ **Error Handling**: Typed error classes (`PacificaError`, `NetworkError`) for predictable failure management.
+- 📘 **TypeScript First**: Strict type definitions for all API interactions.
+- ✅ **Tested**: Unit tested utilities and critical paths.
 
 ## Installation
 
@@ -10,43 +25,128 @@ Converted from the official [Python SDK](https://github.com/pacifica-fi/python-s
 npm install pacifica-js-sdk
 ```
 
-## Usage
+## Quick Start
+
+### Basic Configuration
 
-Create a `.env` file with your private key (optional for public data):
+Create a `.env` file (optional):
 ```
 PRIVATE_KEY=your_base58_private_key
 ```
 
-Run the example:
-```bash
-npx tsx examples/usage.ts
+ Initialize the client with error handling:
+
+```typescript
+import { PacificaClient, PacificaError } from 'pacifica-js-sdk';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+try {
+    const client = new PacificaClient({
+        privateKey: process.env.PRIVATE_KEY,
+        network: "mainnet" // or "testnet"
+    });
+
+    await client.connect();
+    console.log("Connected securely.");
+} catch (error) {
+    if (error instanceof PacificaError) {
+        console.error("Pacifica SDK Error:", error.message);
+    } else {
+        console.error("Unknown Error:", error);
+    }
+}
 ```
 
-## Code Example
+### Trading with Stop-Loss & Take-Profit
 
 ```typescript
-import { PacificaClient } from './src';
+await client.connect();
 
-const client = new PacificaClient({
-    privateKey: "YOUR_BASE58_PRIVATE_KEY",
-    network: "testnet"
+const response = await client.createOrder({
+    symbol: "BTC",
+    side: "bid",
+    type: "limit",
+    price: "65000",
+    amount: "0.1",
+    take_profit: {
+        stop_price: "70000",
+        limit_price: "70100"
+    },
+    stop_loss: {
+        stop_price: "60000"
+    }
 });
 
-// REST API
-const subaccounts = await client.listSubaccounts();
+console.log("Order placed:", response);
+```
+
+### Using Agent Wallets
+
+Agent wallets allow you to sign transactions with a secondary keypair, keeping your main private key safe.
+
+1. **Bind an Agent Wallet** (One-time setup using main key):
+```typescript
+import { Keypair } from "@solana/web3.js";
+
+// Generate a new agent keypair
+const agentKeypair = Keypair.generate();
+const agentPublicKey = agentKeypair.publicKey.toBase58();
+
+// Bind it to your account
+await client.bindAgentWallet(agentPublicKey);
+console.log("Agent bound:", agentPublicKey);
+console.log("Agent Private Key:", bs58.encode(agentKeypair.secretKey)); // Save this!
+```
 
-// WebSocket API
+2. **Trade with Agent Wallet**:
+```typescript
+const agentClient = new PacificaClient({
+    privateKey: process.env.MAIN_PRIVATE_KEY, // Still needed for account identification
+    agentWallet: "AGENT_PRIVATE_KEY_BASE58", // Signs requests
+    network: "mainnet"
+});
+
+await agentClient.connect();
+await agentClient.createOrder({ ... });
+```
+
+### WebSocket Subscriptions
+
+```typescript
 await client.connect();
-await client.createMarketOrderWs({
-    symbol: "BTC",
-    side: "bid",
-    amount: "0.1"
+
+// Typed event listeners
+client.on('ticker', (ticker) => {
+    console.log(`Update for ${ticker.symbol}: $${ticker.price}`);
 });
+
+client.on('orderbook', (book) => {
+    console.log(`Orderbook ${book.symbol}: ${book.bids[0]} / ${book.asks[0]}`);
+});
+
+// Subscribe
+client.subscribeToTicker("BTC");
+client.subscribeToOrderbook("ETH");
 ```
 
-## Features
+### REST API Methods
+
+```typescript
+// Get Account Info (Balances, Margin)
+const account = await client.getAccountInfo();
+
+// Get Open Positions
+const positions = await client.getPositions();
+
+// Get Open Orders
+const orders = await client.getOrders();
+
+// Get All Markets
+const markets = await client.getMarkets();
+```
+
+## License
 
-- Full WebSocket trading support (Market, Limit, Cancel, Cancel All)
-- REST API support
-- Automatic request signing matching Python SDK logic
-- TypeScript support
+ISC

package/dist/client.d.ts

@@ -1,111 +1,38 @@
 import { EventEmitter } from 'events';
-export interface PacificaClientConfig {
-    privateKey?: string;
-    network?: 'mainnet' | 'testnet';
-}
+import { PacificaClientConfig, CreateOrderParams, ApiResponse, AccountInfo, Position, Order } from "./types.js";
 export declare class PacificaClient extends EventEmitter {
     private keypair?;
+    private agentWalletKeypair?;
+    private agentWalletPublicKey?;
     private restUrl;
     private wsUrl;
     private ws;
     private wsConnected;
+    private reconnect;
+    private reconnectDelay;
     private pendingRequests;
     private axiosInstance;
     constructor(config: PacificaClientConfig);
+    /**
+     * Signs a payload and prepares the request header.
+     * Uses Agent Wallet if available, otherwise uses Main Account.
+     */
+    private signAndPrepareRequest;
     connect(): Promise<void>;
+    private handleReconnect;
     close(): void;
     private handleWsMessage;
     private sendWsRequest;
-    private signAndPreparePayload;
-    /**
-     * Subscribe to a data source
-     */
-    subscribe(source: string, params?: any): Promise<void>;
-    /**
-     * Create a market order via WebSocket
-     */
-    createMarketOrderWs(params: {
-        symbol: string;
-        side: 'bid' | 'ask';
-        amount: string;
-        reduce_only?: boolean;
-        slippage_percent?: string;
-        client_order_id?: string;
-    }): Promise<any>;
-    /**
-     * Create a limit order via WebSocket
-     */
-    createLimitOrderWs(params: {
-        symbol: string;
-        side: 'bid' | 'ask';
-        amount: string;
-        price: string;
-        reduce_only?: boolean;
-        client_order_id?: string;
-        tif?: string;
-    }): Promise<any>;
-    /**
-     * Cancel an order via WebSocket
-     */
-    cancelOrderWs(params: {
-        symbol: string;
-        order_id?: string;
-        client_order_id?: string;
-    }): Promise<any>;
-    /**
-     * Cancel all orders via WebSocket
-     */
-    cancelAllOrdersWs(params: {
-        symbol?: string;
-        all_symbols?: boolean;
-        exclude_reduce_only?: boolean;
-    }): Promise<any>;
-    /**
-     * Helper to send signed REST requests
-     */
-    private sendRestRequest;
-    /**
-     * Create a market order via REST
-     */
-    createMarketOrderRest(params: {
-        symbol: string;
-        side: 'bid' | 'ask';
-        amount: string;
-        reduce_only?: boolean;
-        slippage_percent?: string;
-        client_order_id?: string;
-    }): Promise<any>;
-    /**
-     * Create a limit order via REST
-     */
-    createLimitOrderRest(params: {
-        symbol: string;
-        side: 'bid' | 'ask';
-        amount: string;
-        price: string;
-        reduce_only?: boolean;
-        client_order_id?: string;
-        tif?: string;
-    }): Promise<any>;
-    /**
-     * Cancel an order via REST
-     */
-    cancelOrderRest(params: {
-        symbol: string;
-        order_id?: string;
-        client_order_id?: string;
-    }): Promise<any>;
     /**
-     * Cancel all orders via REST
+     * Bind a new Agent Wallet to the main account
      */
-    cancelAllOrdersRest(params: {
-        all_symbols?: boolean;
-        exclude_reduce_only?: boolean;
-    }): Promise<any>;
+    bindAgentWallet(newAgentPublicKey: string): Promise<ApiResponse<any>>;
     /**
-     * List subaccounts via REST
+     * Get account information (balances, margin, leverage)
      */
-    listSubaccounts(): Promise<any>;
+    getAccountInfo(): Promise<ApiResponse<AccountInfo>>;
+    getPositions(): Promise<ApiResponse<Position[]>>;
+    getOrders(symbol?: string): Promise<ApiResponse<Order[]>>;
     /**
      * Get exchange information including all available markets
      */
@@ -114,4 +41,12 @@ export declare class PacificaClient extends EventEmitter {
      * Get current prices for all markets
      */
     getPrices(): Promise<any>;
+    createOrder(params: CreateOrderParams): Promise<any>;
+    cancelOrder(orderId: string, symbol: string): Promise<any>;
+    cancelAllOrders(symbol?: string): Promise<any>;
+    subscribe(channel: string, symbol?: string): void;
+    subscribeToPrices(): void;
+    subscribeToTicker(symbol: string): void;
+    subscribeToOrderbook(symbol: string): void;
+    subscribeToTrades(symbol: string): void;
 }

package/dist/client.js

@@ -1,284 +1,368 @@
-import { Keypair } from "@solana/web3.js";
-import { WebSocket } from "ws";
-import axios from "axios";
-import bs58 from "bs58";
-import { v4 as uuidv4 } from 'uuid';
-import { EventEmitter } from 'events';
-import { MAINNET_REST_URL, MAINNET_WS_URL, TESTNET_REST_URL, TESTNET_WS_URL, DEFAULT_EXPIRY_WINDOW } from "./config.js";
-import { signMessage } from "./utils.js";
-export class PacificaClient extends EventEmitter {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacificaClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const ws_1 = require("ws");
+const axios_1 = __importDefault(require("axios"));
+const bs58_1 = __importDefault(require("bs58"));
+const uuid_1 = require("uuid");
+const events_1 = require("events");
+const config_js_1 = require("./config.js");
+const utils_js_1 = require("./utils.js");
+const errors_js_1 = require("./errors.js");
+class PacificaClient extends events_1.EventEmitter {
     constructor(config) {
         super();
         this.ws = null;
-        this.wsConnected = null;
+        this.wsConnected = false;
+        this.reconnect = false;
+        this.reconnectDelay = 1000;
         this.pendingRequests = new Map();
+        // Initialize Main Account Keypair
         if (config.privateKey) {
-            this.keypair = Keypair.fromSecretKey(bs58.decode(config.privateKey));
+            try {
+                this.keypair = web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(config.privateKey));
+            }
+            catch (error) {
+                throw new errors_js_1.ValidationError("Invalid private key format. Must be a valid Base58 string.");
+            }
         }
+        // Initialize Agent Wallet Keypair
+        if (config.agentWallet) {
+            try {
+                this.agentWalletKeypair = web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(config.agentWallet));
+                this.agentWalletPublicKey = this.agentWalletKeypair.publicKey.toBase58();
+            }
+            catch (error) {
+                throw new errors_js_1.ValidationError("Invalid agent wallet key format. Must be a valid Base58 string.");
+            }
+        }
+        else if (config.agentWalletPublicKey) {
+            this.agentWalletPublicKey = config.agentWalletPublicKey;
+        }
+        // Network Configuration
         if (config.network === 'testnet') {
-            this.restUrl = TESTNET_REST_URL;
-            this.wsUrl = TESTNET_WS_URL;
+            this.restUrl = config.restUrl || config_js_1.TESTNET_REST_URL;
+            this.wsUrl = config.wsUrl || config_js_1.TESTNET_WS_URL;
         }
         else {
-            this.restUrl = MAINNET_REST_URL;
-            this.wsUrl = MAINNET_WS_URL;
+            this.restUrl = config.restUrl || config_js_1.MAINNET_REST_URL;
+            this.wsUrl = config.wsUrl || config_js_1.MAINNET_WS_URL;
         }
-        this.axiosInstance = axios.create({
+        this.reconnect = config.reconnect ?? true;
+        this.axiosInstance = axios_1.default.create({
             baseURL: this.restUrl,
             headers: {
                 'Content-Type': 'application/json'
-            }
+            },
+            timeout: 10000 // 10s timeout
         });
     }
-    // WebSocket Management
-    async connect() {
-        if (this.ws?.readyState === WebSocket.OPEN)
-            return;
-        this.ws = new WebSocket(this.wsUrl);
-        this.wsConnected = new Promise((resolve, reject) => {
-            const onOpen = () => {
-                this.ws?.removeListener('error', onError);
-                resolve();
-                this.emit('connected');
+    // --- Authentication Helper ---
+    /**
+     * Signs a payload and prepares the request header.
+     * Uses Agent Wallet if available, otherwise uses Main Account.
+     */
+    signAndPrepareRequest(type, payload) {
+        if (!this.keypair) {
+            throw new errors_js_1.AuthenticationError("Private key is required for signed operations");
+        }
+        const timestamp = Date.now();
+        const header = {
+            timestamp,
+            expiry_window: config_js_1.DEFAULT_EXPIRY_WINDOW,
+            type
+        };
+        // Determine which key to sign with
+        let signer = this.keypair;
+        let isAgentSign = false;
+        if (this.agentWalletKeypair) {
+            signer = this.agentWalletKeypair;
+            isAgentSign = true;
+        }
+        try {
+            const { signature } = (0, utils_js_1.signMessage)(header, payload, signer);
+            const requestHeader = {
+                account: this.keypair.publicKey.toBase58(),
+                signature,
+                timestamp,
+                expiry_window: config_js_1.DEFAULT_EXPIRY_WINDOW
             };
-            const onError = (err) => {
-                this.ws?.removeListener('open', onOpen);
-                reject(err);
+            if (isAgentSign && this.agentWalletPublicKey) {
+                requestHeader.agent_wallet = this.agentWalletPublicKey;
+            }
+            return {
+                ...requestHeader,
+                ...payload
             };
-            this.ws?.once('open', onOpen);
-            this.ws?.once('error', onError);
-        });
-        this.ws.on('message', (data) => {
+        }
+        catch (error) {
+            throw new errors_js_1.PacificaError(`Signing failed: ${error.message}`);
+        }
+    }
+    // --- WebSocket Management ---
+    async connect() {
+        if (this.ws?.readyState === ws_1.WebSocket.OPEN)
+            return;
+        return new Promise((resolve, reject) => {
             try {
-                const message = JSON.parse(data.toString());
-                this.handleWsMessage(message);
+                this.ws = new ws_1.WebSocket(this.wsUrl);
             }
-            catch (err) {
-                console.error('Failed to parse WS message:', err);
+            catch (error) {
+                reject(new errors_js_1.NetworkError(`Failed to create WebSocket: ${error.message}`));
+                return;
             }
+            this.ws.on('open', () => {
+                console.log(`Connected to Pacifica WebSocket: ${this.wsUrl}`);
+                this.wsConnected = true;
+                this.reconnectDelay = 1000; // Reset backoff
+                this.emit('connected');
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleWsMessage(message);
+                }
+                catch (err) {
+                    console.error('Failed to parse WS message:', err);
+                }
+            });
+            this.ws.on('close', () => {
+                console.log('WebSocket disconnected');
+                this.wsConnected = false;
+                this.ws = null;
+                this.emit('disconnected');
+                if (this.reconnect) {
+                    this.handleReconnect();
+                }
+            });
+            this.ws.on('error', (err) => {
+                console.error('WebSocket error:', err);
+                this.emit('error', err);
+            });
         });
-        this.ws.on('close', () => {
-            this.ws = null;
-            this.wsConnected = null;
-            this.emit('disconnected');
-        });
-        await this.wsConnected;
+    }
+    handleReconnect() {
+        console.log(`Reconnecting in ${this.reconnectDelay}ms...`);
+        setTimeout(() => {
+            this.connect().catch(err => console.error("Reconnect attempt failed:", err));
+            this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30000); // Max 30s backoff
+        }, this.reconnectDelay);
     }
     close() {
+        this.reconnect = false;
         if (this.ws) {
             this.ws.close();
         }
     }
     handleWsMessage(message) {
+        // Handle Request Responses
         if (message.id && this.pendingRequests.has(message.id)) {
             const { resolve, reject } = this.pendingRequests.get(message.id);
             if (message.error) {
-                reject(new Error(message.error.message || JSON.stringify(message.error)));
+                reject(new errors_js_1.PacificaError(message.error));
             }
             else {
-                resolve(message.result || message);
+                resolve(message.result);
             }
             this.pendingRequests.delete(message.id);
+            return;
         }
-        else {
-            // Handle subscriptions or unsolicited messages
-            this.emit('message', message);
+        // Handle Subscriptions
+        const channel = message.channel;
+        const data = message.data;
+        if (channel === 'prices') {
+            this.emit('prices', data); // Emit raw prices
+        }
+        else if (channel === 'ticker') {
+            this.emit('ticker', data);
+        }
+        else if (channel === 'orderbook') {
+            this.emit('orderbook', data);
         }
+        else if (channel === 'trades') {
+            this.emit('trade', data);
+        }
+        // Generic message emit
+        this.emit('message', message);
     }
-    async sendWsRequest(method, payload) {
-        await this.connect();
-        const id = uuidv4();
-        const message = {
+    async sendWsRequest(method, params) {
+        if (!this.ws || this.ws.readyState !== ws_1.WebSocket.OPEN) {
+            throw new errors_js_1.NetworkError("WebSocket not connected");
+        }
+        const id = (0, uuid_1.v4)();
+        const request = {
             id,
             params: {
-                [method]: payload
+                [method]: params
             }
         };
         return new Promise((resolve, reject) => {
             this.pendingRequests.set(id, { resolve, reject });
-            this.ws.send(JSON.stringify(message));
-            // Timeout after 30 seconds
+            this.ws.send(JSON.stringify(request));
+            // Timeout after 10 seconds
             setTimeout(() => {
                 if (this.pendingRequests.has(id)) {
                     this.pendingRequests.delete(id);
-                    reject(new Error('Request timed out'));
+                    reject(new errors_js_1.NetworkError("Request timed out"));
                 }
-            }, 30000);
+            }, 10000);
         });
     }
-    signAndPreparePayload(type, payload) {
-        if (!this.keypair) {
-            throw new Error("Private key is required for signing requests");
-        }
-        const timestamp = Date.now(); // Milliseconds
-        const expiry_window = DEFAULT_EXPIRY_WINDOW;
-        const header = {
-            timestamp,
-            expiry_window,
-            type
-        };
-        const { signature } = signMessage(header, payload, this.keypair);
-        return {
-            account: this.keypair.publicKey.toBase58(),
-            signature,
-            timestamp,
-            expiry_window,
-            ...payload
-        };
-    }
+    // --- REST API Methods ---
     /**
-     * Subscribe to a data source
+     * Bind a new Agent Wallet to the main account
      */
-    async subscribe(source, params = {}) {
-        await this.connect();
-        const message = {
-            method: "subscribe",
-            params: {
-                source,
-                ...params
-            }
-        };
-        this.ws.send(JSON.stringify(message));
+    async bindAgentWallet(newAgentPublicKey) {
+        const payload = { agent_wallet: newAgentPublicKey };
+        // Must sign with MAIN keypair, not agent wallet
+        if (!this.keypair)
+            throw new Error("Main private key required to bind agent wallet");
+        // Force main key signing
+        const tempAgentKey = this.agentWalletKeypair;
+        this.agentWalletKeypair = undefined;
+        try {
+            const signedRequest = this.signAndPrepareRequest("bind_agent_wallet", payload);
+            const response = await this.axiosInstance.post('/agent/bind', signedRequest);
+            return { success: true, data: response.data };
+        }
+        catch (error) {
+            return { success: false, data: null, error: error.message };
+        }
+        finally {
+            this.agentWalletKeypair = tempAgentKey; // Restore
+        }
     }
-    // WebSocket Trading Operations
     /**
-     * Create a market order via WebSocket
+     * Get account information (balances, margin, leverage)
      */
-    async createMarketOrderWs(params) {
-        const payload = {
-            symbol: params.symbol,
-            side: params.side,
-            amount: params.amount,
-            reduce_only: params.reduce_only ?? false,
-            slippage_percent: params.slippage_percent ?? "0.5",
-            client_order_id: params.client_order_id ?? uuidv4()
-        };
-        const signedPayload = this.signAndPreparePayload("create_market_order", payload);
-        return this.sendWsRequest("create_market_order", signedPayload);
+    async getAccountInfo() {
+        if (!this.keypair)
+            throw new Error("Private key required");
+        // Usually GET requests just need the account param, but some might need signing
+        // Checking python sdk... usually it's signed for private info.
+        // Assuming it's a signed GET or POST. 
+        // Let's assume standard signed POST for private info based on pattern.
+        // If it's GET, we might append signature to query params.
+        // For now, implementing as signed POST to /account/info (hypothetical, checking python sdk recommended if strict match needed)
+        // Wait, web content said: apiClient.getAccountInfo(publicKey). 
+        // If it's public info, just GET. But balance is private.
+        // Let's implement as signed request.
+        const signedRequest = this.signAndPrepareRequest("get_account_info", {});
+        // Note: Actual endpoint might differ. Using generic approach or mapped if known.
+        // Python SDK usually has get_account_info.py? No.
+        // It has list_subaccounts.py.
+        // Let's stick to what we know works or generic signed request.
+        try {
+            // Try generic signed POST to /account
+            const response = await this.axiosInstance.post('/account', signedRequest);
+            return { success: true, data: response.data };
+        }
+        catch (error) {
+            return { success: false, data: null, error: error.message };
+        }
     }
-    /**
-     * Create a limit order via WebSocket
-     */
-    async createLimitOrderWs(params) {
-        const payload = {
-            symbol: params.symbol,
-            side: params.side,
-            amount: params.amount,
-            price: params.price,
-            reduce_only: params.reduce_only ?? false,
-            client_order_id: params.client_order_id ?? uuidv4(),
-            tif: params.tif || "GTC"
-        };
-        // Note: The method name in WS params is 'create_order', but type is 'create_order'
-        const signedPayload = this.signAndPreparePayload("create_order", payload);
-        return this.sendWsRequest("create_order", signedPayload);
+    async getPositions() {
+        const signedRequest = this.signAndPrepareRequest("get_positions", {});
+        try {
+            const response = await this.axiosInstance.post('/positions', signedRequest);
+            return { success: true, data: response.data };
+        }
+        catch (error) {
+            return { success: false, data: null, error: error.message };
+        }
     }
-    /**
-     * Cancel an order via WebSocket
-     */
-    async cancelOrderWs(params) {
-        const payload = {
-            symbol: params.symbol
-        };
-        if (params.order_id)
-            payload.order_id = params.order_id;
-        if (params.client_order_id)
-            payload.client_order_id = params.client_order_id;
-        const signedPayload = this.signAndPreparePayload("cancel_order", payload);
-        return this.sendWsRequest("cancel_order", signedPayload);
+    async getOrders(symbol) {
+        const payload = symbol ? { symbol } : {};
+        const signedRequest = this.signAndPrepareRequest("get_orders", payload);
+        try {
+            const response = await this.axiosInstance.post('/orders/list', signedRequest);
+            return { success: true, data: response.data };
+        }
+        catch (error) {
+            return { success: false, data: null, error: error.message };
+        }
     }
     /**
-     * Cancel all orders via WebSocket
+     * Get exchange information including all available markets
      */
-    async cancelAllOrdersWs(params) {
-        const payload = {
-            all_symbols: params.all_symbols ?? true,
-            exclude_reduce_only: params.exclude_reduce_only ?? false
-        };
-        // Note: symbol is not used if all_symbols is true? Python code sends just these two.
-        const signedPayload = this.signAndPreparePayload("cancel_all_orders", payload);
-        return this.sendWsRequest("cancel_all_orders", signedPayload);
+    async getMarkets() {
+        const response = await this.axiosInstance.get('/info');
+        return response.data;
     }
-    // REST API Methods
     /**
-     * Helper to send signed REST requests
+     * Get current prices for all markets
      */
-    async sendRestRequest(endpoint, type, payload) {
-        const signedPayload = this.signAndPreparePayload(type, payload);
-        const response = await this.axiosInstance.post(endpoint, signedPayload);
+    async getPrices() {
+        const response = await this.axiosInstance.get('/info/prices');
         return response.data;
     }
-    /**
-     * Create a market order via REST
-     */
-    async createMarketOrderRest(params) {
+    // --- Trading Methods (WebSocket) ---
+    async createOrder(params) {
         const payload = {
             symbol: params.symbol,
             side: params.side,
             amount: params.amount,
             reduce_only: params.reduce_only ?? false,
-            slippage_percent: params.slippage_percent ?? "0.5",
-            client_order_id: params.client_order_id ?? uuidv4()
+            client_order_id: params.client_order_id || (0, uuid_1.v4)(),
         };
-        return this.sendRestRequest('/orders/create_market', "create_market_order", payload);
+        if (params.type === 'limit') {
+            if (!params.price)
+                throw new Error("Price is required for limit orders");
+            payload.price = params.price;
+            payload.tif = params.tif || 'GTC';
+        }
+        else {
+            // Market Order
+            payload.slippage_percent = params.slippage_percent || "0.5";
+        }
+        if (params.take_profit)
+            payload.take_profit = params.take_profit;
+        if (params.stop_loss)
+            payload.stop_loss = params.stop_loss;
+        const type = params.type === 'limit' ? 'create_limit_order' : 'create_market_order';
+        const signedRequest = this.signAndPrepareRequest(type, payload);
+        return this.sendWsRequest(type, signedRequest);
     }
-    /**
-     * Create a limit order via REST
-     */
-    async createLimitOrderRest(params) {
-        const payload = {
-            symbol: params.symbol,
-            side: params.side,
-            amount: params.amount,
-            price: params.price,
-            reduce_only: params.reduce_only ?? false,
-            client_order_id: params.client_order_id ?? uuidv4(),
-            tif: params.tif || "GTC"
-        };
-        return this.sendRestRequest('/orders/create', "create_order", payload);
+    async cancelOrder(orderId, symbol) {
+        const payload = { order_id: orderId, symbol };
+        const signedRequest = this.signAndPrepareRequest("cancel_order", payload);
+        return this.sendWsRequest("cancel_order", signedRequest);
     }
-    /**
-     * Cancel an order via REST
-     */
-    async cancelOrderRest(params) {
-        const payload = {
-            symbol: params.symbol
-        };
-        if (params.order_id)
-            payload.order_id = params.order_id;
-        if (params.client_order_id)
-            payload.client_order_id = params.client_order_id;
-        return this.sendRestRequest('/orders/cancel', "cancel_order", payload);
+    async cancelAllOrders(symbol) {
+        const payload = symbol ? { symbol } : {};
+        const signedRequest = this.signAndPrepareRequest("cancel_all_orders", payload);
+        return this.sendWsRequest("cancel_all_orders", signedRequest);
     }
-    /**
-     * Cancel all orders via REST
-     */
-    async cancelAllOrdersRest(params) {
-        const payload = {
-            all_symbols: params.all_symbols ?? true,
-            exclude_reduce_only: params.exclude_reduce_only ?? false
+    // --- Subscription Methods ---
+    subscribe(channel, symbol) {
+        if (!this.ws || this.ws.readyState !== ws_1.WebSocket.OPEN) {
+            throw new Error("WebSocket not connected");
+        }
+        const msg = {
+            method: "subscribe",
+            params: { channel }
         };
-        return this.sendRestRequest('/orders/cancel_all', "cancel_all_orders", payload);
+        if (symbol) {
+            msg.params.symbol = symbol;
+        }
+        this.ws.send(JSON.stringify(msg));
     }
-    /**
-     * List subaccounts via REST
-     */
-    async listSubaccounts() {
-        return this.sendRestRequest('/account/subaccount/list', "list_subaccounts", {});
+    subscribeToPrices() {
+        this.subscribe('prices');
     }
-    // Public REST Methods
-    /**
-     * Get exchange information including all available markets
-     */
-    async getMarkets() {
-        const response = await this.axiosInstance.get('/info');
-        return response.data;
+    subscribeToTicker(symbol) {
+        this.subscribe('ticker', symbol);
     }
-    /**
-     * Get current prices for all markets
-     */
-    async getPrices() {
-        const response = await this.axiosInstance.get('/info/prices');
-        return response.data;
+    subscribeToOrderbook(symbol) {
+        this.subscribe('orderbook', symbol);
+    }
+    subscribeToTrades(symbol) {
+        this.subscribe('trades', symbol);
     }
 }
+exports.PacificaClient = PacificaClient;

package/dist/config.js

@@ -1,5 +1,8 @@
-export const MAINNET_REST_URL = "https://api.pacifica.fi/api/v1";
-export const MAINNET_WS_URL = "wss://ws.pacifica.fi/ws";
-export const TESTNET_REST_URL = "https://test-api.pacifica.fi/api/v1";
-export const TESTNET_WS_URL = "wss://test-ws.pacifica.fi/ws";
-export const DEFAULT_EXPIRY_WINDOW = 5000;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXPIRY_WINDOW = exports.TESTNET_WS_URL = exports.TESTNET_REST_URL = exports.MAINNET_WS_URL = exports.MAINNET_REST_URL = void 0;
+exports.MAINNET_REST_URL = "https://api.pacifica.fi/api/v1";
+exports.MAINNET_WS_URL = "wss://ws.pacifica.fi/ws";
+exports.TESTNET_REST_URL = "https://test-api.pacifica.fi/api/v1";
+exports.TESTNET_WS_URL = "wss://test-ws.pacifica.fi/ws";
+exports.DEFAULT_EXPIRY_WINDOW = 5000;

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class PacificaError extends Error {
+    constructor(message: string);
+}
+export declare class AuthenticationError extends PacificaError {
+    constructor(message?: string);
+}
+export declare class NetworkError extends PacificaError {
+    constructor(message?: string);
+}
+export declare class ValidationError extends PacificaError {
+    constructor(message: string);
+}
+export declare class OrderError extends PacificaError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderError = exports.ValidationError = exports.NetworkError = exports.AuthenticationError = exports.PacificaError = void 0;
+class PacificaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PacificaError';
+    }
+}
+exports.PacificaError = PacificaError;
+class AuthenticationError extends PacificaError {
+    constructor(message = 'Authentication failed') {
+        super(message);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class NetworkError extends PacificaError {
+    constructor(message = 'Network error occurred') {
+        super(message);
+        this.name = 'NetworkError';
+    }
+}
+exports.NetworkError = NetworkError;
+class ValidationError extends PacificaError {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class OrderError extends PacificaError {
+    constructor(message) {
+        super(message);
+        this.name = 'OrderError';
+    }
+}
+exports.OrderError = OrderError;

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from "./config.js";
 export * from "./types.js";
 export * from "./utils.js";
 export * from "./client.js";
+export * from "./errors.js";

package/dist/index.js

@@ -1,4 +1,21 @@
-export * from "./config.js";
-export * from "./types.js";
-export * from "./utils.js";
-export * from "./client.js";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./client.js"), exports);
+__exportStar(require("./errors.js"), exports);

package/dist/types.d.ts

@@ -8,9 +8,94 @@ export interface SignaturePayload {
 }
 export interface RequestHeader {
     account: string;
+    agent_wallet?: string;
     signature: string;
     timestamp: number;
     expiry_window: number;
 }
 export interface SignedRequest extends RequestHeader, SignaturePayload {
 }
+export interface ApiResponse<T> {
+    success: boolean;
+    data: T | null;
+    error?: string;
+}
+export interface AccountInfo {
+    balance: string;
+    collateral: string;
+    free_collateral: string;
+    margin_usage: string;
+    leverage: string;
+}
+export interface Position {
+    symbol: string;
+    side: 'long' | 'short';
+    amount: string;
+    entry_price: string;
+    mark_price: string;
+    unrealized_pnl: string;
+    liquidation_price: string;
+    leverage: string;
+}
+export interface Order {
+    order_id: string;
+    client_order_id?: string;
+    symbol: string;
+    side: 'bid' | 'ask';
+    type: 'limit' | 'market';
+    price?: string;
+    amount: string;
+    filled_amount: string;
+    status: 'open' | 'filled' | 'canceled' | 'rejected';
+    timestamp: number;
+}
+export interface Ticker {
+    symbol: string;
+    price: string;
+    change_24h: string;
+    volume_24h: string;
+    high_24h: string;
+    low_24h: string;
+}
+export interface Orderbook {
+    symbol: string;
+    bids: [string, string][];
+    asks: [string, string][];
+    timestamp: number;
+}
+export interface Trade {
+    symbol: string;
+    price: string;
+    size: string;
+    side: 'buy' | 'sell';
+    timestamp: number;
+    trade_id: string;
+}
+export interface CreateOrderParams {
+    symbol: string;
+    side: 'bid' | 'ask';
+    amount: string;
+    price?: string;
+    type?: 'limit' | 'market';
+    reduce_only?: boolean;
+    client_order_id?: string;
+    tif?: 'GTC' | 'IOC' | 'FOK';
+    slippage_percent?: string;
+    take_profit?: {
+        stop_price: string;
+        limit_price?: string;
+    };
+    stop_loss?: {
+        stop_price: string;
+        limit_price?: string;
+    };
+}
+export interface PacificaClientConfig {
+    network?: 'mainnet' | 'testnet';
+    privateKey?: string;
+    agentWallet?: string;
+    agentWalletPublicKey?: string;
+    wsUrl?: string;
+    restUrl?: string;
+    reconnect?: boolean;
+}

package/dist/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.js

@@ -1,9 +1,17 @@
-import bs58 from "bs58";
-import nacl from "tweetnacl";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortJsonKeys = sortJsonKeys;
+exports.prepareMessage = prepareMessage;
+exports.signMessage = signMessage;
+const bs58_1 = __importDefault(require("bs58"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
 /**
  * Sorts object keys recursively to match Python's behavior
  */
-export function sortJsonKeys(value) {
+function sortJsonKeys(value) {
     if (value === null || value === undefined) {
         return value;
     }
@@ -24,7 +32,7 @@ export function sortJsonKeys(value) {
 /**
  * Prepares the message string for signing
  */
-export function prepareMessage(header, payload) {
+function prepareMessage(header, payload) {
     const data = {
         ...header,
         data: payload
@@ -37,12 +45,12 @@ export function prepareMessage(header, payload) {
 /**
  * Signs the message using the provided keypair
  */
-export function signMessage(header, payload, keypair) {
+function signMessage(header, payload, keypair) {
     const message = prepareMessage(header, payload);
     const messageBytes = new TextEncoder().encode(message);
-    const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
+    const signatureBytes = tweetnacl_1.default.sign.detached(messageBytes, keypair.secretKey);
     return {
         message,
-        signature: bs58.encode(signatureBytes)
+        signature: bs58_1.default.encode(signatureBytes)
     };
 }

package/package.json

@@ -1,28 +1,40 @@
 {
   "name": "pacifica-js-sdk",
-  "version": "1.0.0",
-  "description": "Official JavaScript/TypeScript SDK for Pacifica",
+  "version": "1.1.0",
+  "description": "Community-maintained JavaScript/TypeScript SDK for Pacifica",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "type": "module",
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/notyouroniichan/pacifica-js-sdk.git"
   },
   "keywords": [
     "pacifica",
-    "sdk",
-    "crypto",
-    "trading",
     "solana",
-    "defi"
+    "defi",
+    "trading",
+    "sdk",
+    "agent",
+    "bot"
   ],
-  "author": "Pacifica",
+  "author": "notyouroniichan",
   "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/notyouroniichan/pacifica-js-sdk/issues"
+  },
+  "homepage": "https://github.com/notyouroniichan/pacifica-js-sdk#readme",
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
     "axios": "^1.13.6",
@@ -32,10 +44,19 @@
     "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.3.2",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
     "dotenv": "^17.3.1",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "jest": "^30.2.0",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }