perp-cli 0.3.3

package/dist/pacifica/signing.js

@@ -0,0 +1,97 @@
+import bs58 from "bs58";
+import { DEFAULT_EXPIRY_WINDOW } from "./constants.js";
+/**
+ * Recursively sort all object keys alphabetically.
+ * Exact port of Python SDK's sort_json_keys().
+ */
+export function sortJsonKeys(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(sortJsonKeys);
+    }
+    if (typeof value === "object") {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = sortJsonKeys(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/**
+ * Prepare the message string for signing.
+ * Exact port of Python SDK's prepare_message().
+ *
+ * Header must contain: type, timestamp, expiry_window
+ * Returns compact JSON with sorted keys and payload nested under "data".
+ */
+export function prepareMessage(header, payload) {
+    if (!header.type || !header.timestamp || !header.expiry_window) {
+        throw new Error("Header must have type, timestamp, and expiry_window");
+    }
+    const data = {
+        ...header,
+        data: payload,
+    };
+    const sorted = sortJsonKeys(data);
+    // JSON.stringify with no space args produces compact JSON (same as Python separators=(",",":"))
+    return JSON.stringify(sorted);
+}
+/**
+ * Create a signing header with current timestamp.
+ */
+export function createHeader(type, expiryWindow = DEFAULT_EXPIRY_WINDOW) {
+    return {
+        type,
+        timestamp: Date.now(),
+        expiry_window: expiryWindow,
+    };
+}
+/**
+ * Sign a message using a wallet adapter's signMessage function.
+ * Used in browser context with Phantom/Solflare/etc.
+ *
+ * @param header - Operation header (type, timestamp, expiry_window)
+ * @param payload - Operation payload
+ * @param signMessage - Wallet adapter's signMessage function
+ * @returns [message, base58EncodedSignature]
+ */
+export async function signWithWallet(header, payload, signMessage) {
+    const message = prepareMessage(header, payload);
+    const messageBytes = new TextEncoder().encode(message);
+    const signatureBytes = await signMessage(messageBytes);
+    const signature = bs58.encode(signatureBytes);
+    return [message, signature];
+}
+/**
+ * Build a signed request body for REST API POST.
+ * Flattens payload to top level and adds account, signature, timestamp, expiry_window.
+ */
+export async function buildSignedRequest(operationType, payload, account, signMessage, expiryWindow = DEFAULT_EXPIRY_WINDOW) {
+    const header = createHeader(operationType, expiryWindow);
+    const [, signature] = await signWithWallet(header, payload, signMessage);
+    return {
+        account,
+        signature,
+        timestamp: header.timestamp,
+        expiry_window: header.expiry_window,
+        ...payload,
+    };
+}
+/**
+ * Build a signed request with agent wallet.
+ * Used when an agent wallet is trading on behalf of a main account.
+ */
+export async function buildAgentSignedRequest(operationType, payload, mainAccount, agentWallet, signMessage, expiryWindow = DEFAULT_EXPIRY_WINDOW) {
+    const header = createHeader(operationType, expiryWindow);
+    const [, signature] = await signWithWallet(header, payload, signMessage);
+    return {
+        account: mainAccount,
+        agent_wallet: agentWallet,
+        signature,
+        timestamp: header.timestamp,
+        expiry_window: header.expiry_window,
+        ...payload,
+    };
+}

package/dist/pacifica/types/account.d.ts

@@ -0,0 +1,42 @@
+export interface AccountInfo {
+    balance: string;
+    fee_level: number;
+    maker_fee: string;
+    taker_fee: string;
+    account_equity: string;
+    available_to_spend: string;
+    available_to_withdraw: string;
+    pending_balance: string;
+    pending_interest: string;
+    total_margin_used: string;
+    cross_mmr: string;
+    positions_count: number;
+    orders_count: number;
+    stop_orders_count: number;
+}
+export interface AccountSettings {
+    symbol: string;
+    margin_mode: "cross" | "isolated";
+    leverage: number;
+}
+export interface SubaccountInfo {
+    subaccount_name: string;
+    subaccount_address: string;
+}
+export interface TransferFundsParams {
+    from_account: string;
+    to_account: string;
+    amount: string;
+}
+export interface WithdrawParams {
+    amount: string;
+    dest_address: string;
+}
+export interface UpdateLeverageParams {
+    symbol: string;
+    leverage: number;
+}
+export interface UpdateMarginModeParams {
+    symbol: string;
+    is_isolated: boolean;
+}

package/dist/pacifica/types/account.js

@@ -0,0 +1 @@
+export {};

package/dist/pacifica/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./market.js";
+export * from "./order.js";
+export * from "./position.js";
+export * from "./account.js";
+export * from "./ws.js";
+export * from "./lake.js";

package/dist/pacifica/types/index.js

@@ -0,0 +1,6 @@
+export * from "./market.js";
+export * from "./order.js";
+export * from "./position.js";
+export * from "./account.js";
+export * from "./ws.js";
+export * from "./lake.js";

package/dist/pacifica/types/lake.d.ts

@@ -0,0 +1,18 @@
+export interface CreateLakeParams {
+    symbol: string;
+    amount: string;
+}
+export interface LakeDepositParams {
+    lake_id: string;
+    amount: string;
+}
+export interface LakeWithdrawParams {
+    lake_id: string;
+    amount: string;
+}
+export interface LakeInfo {
+    lake_id: string;
+    symbol: string;
+    amount: string;
+    created_at: number;
+}

package/dist/pacifica/types/lake.js

@@ -0,0 +1 @@
+export {};

package/dist/pacifica/types/market.d.ts

@@ -0,0 +1,64 @@
+export interface MarketInfo {
+    symbol: string;
+    tick_size: string;
+    lot_size: string;
+    max_leverage: number;
+    funding_rate: string;
+    next_funding_rate: string;
+    open_interest: string;
+    volume_24h: string;
+    mark_price: string;
+    index_price: string;
+}
+export interface PriceInfo {
+    symbol: string;
+    mark: string;
+    mid: string;
+    oracle: string;
+    funding: string;
+    next_funding: string;
+    open_interest: string;
+    volume_24h: string;
+    timestamp: number;
+}
+export interface OrderbookEntry {
+    p: string;
+    a: string;
+    n: number;
+}
+export interface Orderbook {
+    s: string;
+    l: [OrderbookEntry[], OrderbookEntry[]];
+    t: number;
+    li: number;
+}
+export interface Trade {
+    event_type: string;
+    price: string;
+    amount: string;
+    side: "bid" | "ask";
+    cause: string;
+    created_at: number;
+}
+export interface Kline {
+    t: number;
+    T: number;
+    s: string;
+    i: string;
+    o: string;
+    c: string;
+    h: string;
+    l: string;
+    v: string;
+    n: number;
+}
+export interface FundingRateHistory {
+    oracle_price: string;
+    bid_impact_price: string;
+    ask_impact_price: string;
+    funding_rate: string;
+    next_funding_rate: string;
+    created_at: number;
+}
+export type KlineInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d";
+export type AggLevel = 1 | 10 | 100 | 1000 | 10000;

package/dist/pacifica/types/market.js

@@ -0,0 +1 @@
+export {};

package/dist/pacifica/types/order.d.ts

@@ -0,0 +1,92 @@
+export type Side = "bid" | "ask";
+export type TimeInForce = "GTC" | "IOC" | "ALO" | "TOB";
+export interface MarketOrderParams {
+    symbol: string;
+    amount: string;
+    side: Side;
+    slippage_percent: string;
+    reduce_only: boolean;
+    client_order_id?: string;
+}
+export interface LimitOrderParams {
+    symbol: string;
+    price: string;
+    amount: string;
+    side: Side;
+    tif: TimeInForce;
+    reduce_only: boolean;
+    client_order_id?: string;
+}
+export interface StopOrderParams {
+    symbol: string;
+    side: Side;
+    reduce_only: boolean;
+    stop_order: {
+        stop_price: string;
+        amount: string;
+        limit_price?: string;
+        client_order_id?: string;
+    };
+}
+export interface EditOrderParams {
+    symbol: string;
+    order_id: number;
+    price: string;
+    amount: string;
+}
+export interface CancelOrderParams {
+    symbol: string;
+    order_id?: number;
+    client_order_id?: string;
+}
+export interface CancelAllOrdersParams {
+    all_symbols: boolean;
+    exclude_reduce_only: boolean;
+}
+export interface TWAPParams {
+    symbol: string;
+    amount: string;
+    side: Side;
+    slippage_percent?: string;
+    reduce_only?: boolean;
+    duration_in_seconds: number;
+    client_order_id?: string;
+}
+export interface CancelTWAPParams {
+    symbol: string;
+    twap_order_id: number;
+}
+export interface TPSLParams {
+    symbol: string;
+    side: Side;
+    take_profit?: {
+        stop_price: string;
+        limit_price?: string;
+        amount?: string;
+    };
+    stop_loss?: {
+        stop_price: string;
+    };
+}
+export type BatchActionType = "Create" | "Cancel";
+export interface BatchAction {
+    type: BatchActionType;
+    data: Record<string, unknown>;
+}
+export interface OrderInfo {
+    order_id: number;
+    client_order_id: string | null;
+    symbol: string;
+    side: Side;
+    price: string;
+    initial_amount: string;
+    filled_amount: string;
+    cancelled_amount: string;
+    stop_price: string | null;
+    order_type: string;
+    stop_parent_order_id: number | null;
+    trigger_price_type: string | null;
+    reduce_only: boolean;
+    created_at: number;
+    updated_at: number;
+}

package/dist/pacifica/types/order.js

@@ -0,0 +1 @@
+export {};

package/dist/pacifica/types/position.d.ts

@@ -0,0 +1,25 @@
+import type { Side } from "./order.js";
+export interface Position {
+    symbol: string;
+    side: Side;
+    amount: string;
+    entry_price: string;
+    mark_price: string;
+    liquidation_price: string;
+    unrealized_pnl: string;
+    margin_used: string;
+    leverage: number;
+    created_at: number;
+}
+export interface PositionTPSL {
+    symbol: string;
+    side: Side;
+    take_profit?: {
+        stop_price: string;
+        limit_price?: string;
+        amount?: string;
+    };
+    stop_loss?: {
+        stop_price: string;
+    };
+}

package/dist/pacifica/types/position.js

@@ -0,0 +1 @@
+export {};

package/dist/pacifica/types/ws.d.ts

@@ -0,0 +1,34 @@
+export type PublicChannel = "prices" | "book" | "bbo" | "trades" | "candle" | "mark_price_candle";
+export type PrivateChannel = "account_positions" | "account_order_updates" | "account_info" | "account_margin" | "account_leverage" | "account_trades" | "account_twap_orders" | "account_twap_order_updates";
+export type Channel = PublicChannel | PrivateChannel;
+export interface WSSubscription {
+    method: "subscribe" | "unsubscribe";
+    params: {
+        source: Channel;
+        [key: string]: unknown;
+    };
+}
+export type WSTradingMethod = "create_order" | "create_market_order" | "edit_order" | "batch_order" | "cancel_order" | "cancel_all_orders";
+export interface WSTradingRequest {
+    id: string;
+    params: Record<string, unknown>;
+}
+export interface WSTradingResponse {
+    code: number;
+    data: Record<string, unknown>;
+    id: string;
+    t: number;
+    type: string;
+}
+export declare const ORDER_UPDATE_FIELDS: Record<string, string>;
+export declare const ACCOUNT_INFO_FIELDS: Record<string, string>;
+export declare const WS_CODES: {
+    readonly SUCCESS: 200;
+    readonly INVALID_REQUEST: 400;
+    readonly INVALID_SIGNATURE: 401;
+    readonly INVALID_SIGNER: 402;
+    readonly UNAUTHORIZED: 403;
+    readonly ENGINE_ERROR: 420;
+    readonly RATE_LIMIT: 429;
+    readonly UNKNOWN_ERROR: 500;
+};

package/dist/pacifica/types/ws.js

@@ -0,0 +1,41 @@
+// Field abbreviation mappings for order updates
+export const ORDER_UPDATE_FIELDS = {
+    i: "order_id",
+    I: "client_order_id",
+    u: "account",
+    s: "symbol",
+    d: "side",
+    p: "price",
+    a: "amount",
+    f: "filled",
+    oe: "order_event",
+    os: "order_status",
+    ot: "order_type",
+    li: "last_order_id",
+};
+// Field abbreviation mappings for account info
+export const ACCOUNT_INFO_FIELDS = {
+    b: "balance",
+    f: "fee_level",
+    ae: "account_equity",
+    as: "available_to_spend",
+    aw: "available_to_withdraw",
+    pb: "pending_balance",
+    mu: "margin_used",
+    cm: "cross_mmr",
+    pc: "positions_count",
+    oc: "orders_count",
+    sc: "stop_orders_count",
+    t: "timestamp",
+};
+// WS error codes
+export const WS_CODES = {
+    SUCCESS: 200,
+    INVALID_REQUEST: 400,
+    INVALID_SIGNATURE: 401,
+    INVALID_SIGNER: 402,
+    UNAUTHORIZED: 403,
+    ENGINE_ERROR: 420,
+    RATE_LIMIT: 429,
+    UNKNOWN_ERROR: 500,
+};

package/dist/pacifica/ws-client.d.ts

@@ -0,0 +1,42 @@
+import { type Network } from "./constants.js";
+import type { Channel, PublicChannel, PrivateChannel, WSTradingResponse } from "./types/ws.js";
+type MessageHandler = (data: unknown) => void;
+type SignMessageFn = (message: Uint8Array) => Promise<Uint8Array>;
+export interface PacificaWSConfig {
+    network?: Network;
+    wsUrl?: string;
+    apiKey?: string;
+    autoReconnect?: boolean;
+    heartbeatInterval?: number;
+}
+export declare class PacificaWSClient {
+    private ws;
+    private wsUrl;
+    private apiKey?;
+    private autoReconnect;
+    private heartbeatInterval;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private handlers;
+    private tradingCallbacks;
+    private isConnected;
+    constructor(config?: PacificaWSConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private send;
+    private handleMessage;
+    subscribe(channel: PublicChannel, params?: Record<string, unknown>): void;
+    subscribePrivate(channel: PrivateChannel, account: string): void;
+    unsubscribe(channel: Channel, params?: Record<string, unknown>): void;
+    on(channel: string, handler: MessageHandler): void;
+    off(channel: string, handler: MessageHandler): void;
+    createOrder(params: Record<string, unknown>, account: string, signMessage: SignMessageFn): Promise<WSTradingResponse>;
+    createMarketOrder(params: Record<string, unknown>, account: string, signMessage: SignMessageFn): Promise<WSTradingResponse>;
+    editOrder(params: Record<string, unknown>, account: string, signMessage: SignMessageFn): Promise<WSTradingResponse>;
+    cancelOrder(params: Record<string, unknown>, account: string, signMessage: SignMessageFn): Promise<WSTradingResponse>;
+    cancelAllOrders(params: Record<string, unknown>, account: string, signMessage: SignMessageFn): Promise<WSTradingResponse>;
+    private sendTradingCommand;
+}
+export {};

package/dist/pacifica/ws-client.js

@@ -0,0 +1,180 @@
+import { getNetworkConfig } from "./constants.js";
+import { buildSignedRequest } from "./signing.js";
+export class PacificaWSClient {
+    ws = null;
+    wsUrl;
+    apiKey;
+    autoReconnect;
+    heartbeatInterval;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    handlers = new Map();
+    tradingCallbacks = new Map();
+    isConnected = false;
+    constructor(config = {}) {
+        this.wsUrl = config.wsUrl || getNetworkConfig(config.network).wsUrl;
+        this.apiKey = config.apiKey;
+        this.autoReconnect = config.autoReconnect ?? true;
+        this.heartbeatInterval = config.heartbeatInterval ?? 30000;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                const url = this.apiKey ? `${this.wsUrl}?PF-API-KEY=${this.apiKey}` : this.wsUrl;
+                this.ws = new WebSocket(url);
+                this.ws.onopen = () => {
+                    this.isConnected = true;
+                    this.startHeartbeat();
+                    resolve();
+                };
+                this.ws.onmessage = (event) => {
+                    this.handleMessage(event.data);
+                };
+                this.ws.onclose = () => {
+                    this.isConnected = false;
+                    this.stopHeartbeat();
+                    if (this.autoReconnect) {
+                        this.reconnectTimer = setTimeout(() => this.connect(), 3000);
+                    }
+                };
+                this.ws.onerror = (err) => {
+                    if (!this.isConnected)
+                        reject(err);
+                };
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    disconnect() {
+        this.autoReconnect = false;
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.isConnected = false;
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.send({ method: "ping" });
+        }, this.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    send(data) {
+        if (this.ws && this.isConnected) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    handleMessage(raw) {
+        try {
+            const text = typeof raw === "string" ? raw : "";
+            if (!text)
+                return;
+            const msg = JSON.parse(text);
+            // Pong response
+            if (msg.channel === "pong")
+                return;
+            // Trading response (has id field)
+            if (msg.id && this.tradingCallbacks.has(msg.id)) {
+                const cb = this.tradingCallbacks.get(msg.id);
+                this.tradingCallbacks.delete(msg.id);
+                cb(msg);
+                return;
+            }
+            // Channel data
+            const channel = msg.channel || msg.source;
+            if (channel) {
+                const cbs = this.handlers.get(channel);
+                if (cbs) {
+                    cbs.forEach((cb) => cb(msg));
+                }
+            }
+            // Global handler
+            const allCbs = this.handlers.get("*");
+            if (allCbs) {
+                allCbs.forEach((cb) => cb(msg));
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // ==================== SUBSCRIPTIONS ====================
+    subscribe(channel, params) {
+        this.send({
+            method: "subscribe",
+            params: { source: channel, ...params },
+        });
+    }
+    subscribePrivate(channel, account) {
+        this.send({
+            method: "subscribe",
+            params: { source: channel, account },
+        });
+    }
+    unsubscribe(channel, params) {
+        this.send({
+            method: "unsubscribe",
+            params: { source: channel, ...params },
+        });
+    }
+    on(channel, handler) {
+        if (!this.handlers.has(channel)) {
+            this.handlers.set(channel, new Set());
+        }
+        this.handlers.get(channel).add(handler);
+    }
+    off(channel, handler) {
+        this.handlers.get(channel)?.delete(handler);
+    }
+    // ==================== WS TRADING ====================
+    async createOrder(params, account, signMessage) {
+        const id = crypto.randomUUID();
+        const body = await buildSignedRequest("create_order", params, account, signMessage);
+        return this.sendTradingCommand(id, { create_order: body });
+    }
+    async createMarketOrder(params, account, signMessage) {
+        const id = crypto.randomUUID();
+        const body = await buildSignedRequest("create_market_order", params, account, signMessage);
+        return this.sendTradingCommand(id, { create_market_order: body });
+    }
+    async editOrder(params, account, signMessage) {
+        const id = crypto.randomUUID();
+        const body = await buildSignedRequest("edit_order", params, account, signMessage);
+        return this.sendTradingCommand(id, { edit_order: body });
+    }
+    async cancelOrder(params, account, signMessage) {
+        const id = crypto.randomUUID();
+        const body = await buildSignedRequest("cancel_order", params, account, signMessage);
+        return this.sendTradingCommand(id, { cancel_order: body });
+    }
+    async cancelAllOrders(params, account, signMessage) {
+        const id = crypto.randomUUID();
+        const body = await buildSignedRequest("cancel_all_orders", params, account, signMessage);
+        return this.sendTradingCommand(id, { cancel_all_orders: body });
+    }
+    sendTradingCommand(id, params) {
+        return new Promise((resolve, reject) => {
+            this.tradingCallbacks.set(id, resolve);
+            this.send({ id, params });
+            // Timeout after 10s
+            setTimeout(() => {
+                if (this.tradingCallbacks.has(id)) {
+                    this.tradingCallbacks.delete(id);
+                    reject(new Error(`Trading command ${id} timed out`));
+                }
+            }, 10000);
+        });
+    }
+}