perp-cli 0.4.0 → 0.4.8

package/dist/settings.d.ts

@@ -1,3 +1,7 @@
+export interface ExchangeFees {
+    taker: number;
+    maker: number;
+}
 export interface Settings {
     /** Default exchange when -e flag is omitted */
     defaultExchange: string;
@@ -14,6 +18,8 @@ export interface Settings {
         hyperliquid: boolean;
         lighter: boolean;
     };
+    /** Per-exchange fee tiers (fetched from exchange APIs) */
+    fees: Record<string, ExchangeFees>;
 }
 export declare function loadSettings(): Settings;
 export declare function saveSettings(settings: Settings): void;

package/dist/settings.js

@@ -14,12 +14,27 @@ const DEFAULTS = {
         hyperliquid: false,
         lighter: false,
     },
+    fees: {
+        hyperliquid: { taker: 0.00035, maker: 0.00002 },
+        pacifica: { taker: 0.00035, maker: 0.0001 },
+        lighter: { taker: 0, maker: 0 },
+    },
 };
 export function loadSettings() {
     if (!existsSync(SETTINGS_FILE))
-        return { ...DEFAULTS, referralCodes: { ...DEFAULTS.referralCodes } };
+        return { ...DEFAULTS, referralCodes: { ...DEFAULTS.referralCodes }, fees: { ...DEFAULTS.fees } };
     try {
         const stored = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+        // Merge stored fees with defaults (so new exchanges get defaults)
+        const fees = { ...DEFAULTS.fees };
+        if (stored.fees && typeof stored.fees === "object") {
+            for (const [ex, f] of Object.entries(stored.fees)) {
+                const fee = f;
+                if (fee && typeof fee.taker === "number" && typeof fee.maker === "number") {
+                    fees[ex] = { taker: fee.taker, maker: fee.maker };
+                }
+            }
+        }
         return {
             defaultExchange: stored.defaultExchange ?? DEFAULTS.defaultExchange,
             referrals: stored.referrals ?? DEFAULTS.referrals,
@@ -32,10 +47,11 @@ export function loadSettings() {
                 hyperliquid: stored.referralApplied?.hyperliquid ?? DEFAULTS.referralApplied.hyperliquid,
                 lighter: stored.referralApplied?.lighter ?? DEFAULTS.referralApplied.lighter,
             },
+            fees,
         };
     }
     catch {
-        return { ...DEFAULTS, referralCodes: { ...DEFAULTS.referralCodes } };
+        return { ...DEFAULTS, referralCodes: { ...DEFAULTS.referralCodes }, fees: { ...DEFAULTS.fees } };
     }
 }
 export function saveSettings(settings) {

package/dist/signer/evm-local.d.ts

@@ -0,0 +1,12 @@
+import type { EvmSigner } from "./interface.js";
+export declare class LocalEvmSigner implements EvmSigner {
+    private _wallet;
+    private constructor();
+    static create(privateKey: string): Promise<LocalEvmSigner>;
+    getAddress(): string;
+    signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, value: Record<string, unknown>): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+}

package/dist/signer/evm-local.js

@@ -0,0 +1,19 @@
+export class LocalEvmSigner {
+    _wallet;
+    constructor() { }
+    static async create(privateKey) {
+        const { ethers } = await import("ethers");
+        const signer = new LocalEvmSigner();
+        signer._wallet = new ethers.Wallet(privateKey);
+        return signer;
+    }
+    getAddress() {
+        return this._wallet.address;
+    }
+    async signTypedData(domain, types, value) {
+        return this._wallet.signTypedData(domain, types, value);
+    }
+    async signMessage(message) {
+        return this._wallet.signMessage(message);
+    }
+}

package/dist/signer/index.d.ts

@@ -0,0 +1,3 @@
+export type { EvmSigner, SolanaSigner } from "./interface.js";
+export { LocalEvmSigner } from "./evm-local.js";
+export { LocalSolanaSigner } from "./solana-local.js";

package/dist/signer/index.js

@@ -0,0 +1,2 @@
+export { LocalEvmSigner } from "./evm-local.js";
+export { LocalSolanaSigner } from "./solana-local.js";

package/dist/signer/interface.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Signer interfaces for exchange adapters.
+ *
+ * Separates signing logic from adapters so it can be injected
+ * (e.g., HSM, hardware wallet, delegated signing).
+ */
+/** EVM signer (Hyperliquid + Lighter L1) */
+export interface EvmSigner {
+    getAddress(): string;
+    /** EIP-712 typed data signing — returns flat hex signature (0x...) */
+    signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, value: Record<string, unknown>): Promise<string>;
+    /** EIP-191 personal message signing — returns hex signature */
+    signMessage(message: string | Uint8Array): Promise<string>;
+}
+/** Solana signer (Pacifica) */
+export interface SolanaSigner {
+    getPublicKeyBase58(): string;
+    /** Ed25519 detached signature */
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    /** Sign a Solana transaction (full sign) */
+    signTransaction(tx: {
+        sign(keypair: unknown): void;
+    }): void;
+    /** Partially sign a Solana transaction */
+    partialSignTransaction(tx: {
+        partialSign(keypair: unknown): void;
+    }): void;
+}

package/dist/signer/interface.js

@@ -0,0 +1,7 @@
+/**
+ * Signer interfaces for exchange adapters.
+ *
+ * Separates signing logic from adapters so it can be injected
+ * (e.g., HSM, hardware wallet, delegated signing).
+ */
+export {};

package/dist/signer/solana-local.d.ts

@@ -0,0 +1,13 @@
+import type { SolanaSigner } from "./interface.js";
+export declare class LocalSolanaSigner implements SolanaSigner {
+    private _keypair;
+    constructor(keypair: import("@solana/web3.js").Keypair);
+    getPublicKeyBase58(): string;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    signTransaction(tx: {
+        sign(keypair: unknown): void;
+    }): void;
+    partialSignTransaction(tx: {
+        partialSign(keypair: unknown): void;
+    }): void;
+}

package/dist/signer/solana-local.js

@@ -0,0 +1,19 @@
+export class LocalSolanaSigner {
+    _keypair;
+    constructor(keypair) {
+        this._keypair = keypair;
+    }
+    getPublicKeyBase58() {
+        return this._keypair.publicKey.toBase58();
+    }
+    async signMessage(message) {
+        const nacl = await import("tweetnacl");
+        return nacl.default.sign.detached(message, this._keypair.secretKey);
+    }
+    signTransaction(tx) {
+        tx.sign(this._keypair);
+    }
+    partialSignTransaction(tx) {
+        tx.partialSign(this._keypair);
+    }
+}

package/dist/smart-order.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Smart Order Execution — best bid/ask + 1 tick pricing.
+ *
+ * Instead of `marketOrder()` which can sweep deep into the book (Hyperliquid
+ * DEX uses 5% slippage by default), this fetches the orderbook and places an
+ * order at exactly the best available price plus one tick.
+ *
+ * For buys:  limit price = best ask + 1 tick  (fills at best ask or better)
+ * For sells: limit price = best bid - 1 tick  (fills at best bid or better)
+ *
+ * Uses IOC (Immediate-Or-Cancel) so the order fills instantly at the best
+ * level and any unfilled remainder is cancelled — no resting orders left.
+ *
+ * Benefits:
+ * - Fills only at the top-of-book price (no multi-level sweep)
+ * - Saves 5-50+ bps vs raw market orders on thin books
+ * - Predictable execution price
+ *
+ * Fallback: if the IOC limit fails, falls back to market order.
+ */
+import type { ExchangeAdapter } from "./exchanges/interface.js";
+export interface SmartOrderOpts {
+    /** Extra ticks of tolerance beyond best price. Default: 1 */
+    tickTolerance?: number;
+    /** Fall back to market order if IOC limit fails. Default: true */
+    fallback?: boolean;
+    /** Reduce only flag for closing positions. Default: false */
+    reduceOnly?: boolean;
+}
+export interface SmartOrderResult {
+    result: unknown;
+    method: "limit_ioc" | "market_fallback";
+    /** The actual limit price used for the order */
+    price: string;
+    /** The best price from the orderbook */
+    bestBookPrice: string;
+    /** Tick size inferred from orderbook */
+    tickSize: string;
+}
+/**
+ * Execute a smart order at best bid/ask + 1 tick.
+ * Drop-in replacement for `adapter.marketOrder()`.
+ */
+export declare function smartOrder(adapter: ExchangeAdapter, symbol: string, side: "buy" | "sell", size: string, opts?: SmartOrderOpts): Promise<SmartOrderResult>;

package/dist/smart-order.js

@@ -0,0 +1,145 @@
+/**
+ * Smart Order Execution — best bid/ask + 1 tick pricing.
+ *
+ * Instead of `marketOrder()` which can sweep deep into the book (Hyperliquid
+ * DEX uses 5% slippage by default), this fetches the orderbook and places an
+ * order at exactly the best available price plus one tick.
+ *
+ * For buys:  limit price = best ask + 1 tick  (fills at best ask or better)
+ * For sells: limit price = best bid - 1 tick  (fills at best bid or better)
+ *
+ * Uses IOC (Immediate-Or-Cancel) so the order fills instantly at the best
+ * level and any unfilled remainder is cancelled — no resting orders left.
+ *
+ * Benefits:
+ * - Fills only at the top-of-book price (no multi-level sweep)
+ * - Saves 5-50+ bps vs raw market orders on thin books
+ * - Predictable execution price
+ *
+ * Fallback: if the IOC limit fails, falls back to market order.
+ */
+/**
+ * Infer tick size from orderbook prices.
+ * Uses the minimum price increment visible in the book.
+ */
+function inferTickSize(levels) {
+    if (levels.length < 2) {
+        // Single level: infer from decimal places (e.g., "1.234" → tick = 0.001)
+        const price = levels[0]?.[0] ?? "1";
+        const decimals = price.includes(".") ? price.split(".")[1].length : 0;
+        return decimals > 0 ? Math.pow(10, -decimals) : 1;
+    }
+    // Use minimum difference between adjacent price levels
+    // Determine max decimal places from the orderbook to round away float noise
+    let maxDecimals = 0;
+    for (let i = 0; i < Math.min(levels.length, 5); i++) {
+        const p = levels[i][0];
+        const d = p.includes(".") ? p.split(".")[1].length : 0;
+        if (d > maxDecimals)
+            maxDecimals = d;
+    }
+    let minDiff = Infinity;
+    for (let i = 1; i < Math.min(levels.length, 5); i++) {
+        const diff = Math.abs(Number(levels[i][0]) - Number(levels[i - 1][0]));
+        if (diff > 0 && diff < minDiff)
+            minDiff = diff;
+    }
+    if (minDiff === Infinity) {
+        return Math.pow(10, -maxDecimals);
+    }
+    // Round to orderbook precision to eliminate floating-point noise
+    // e.g., 0.10000000000000142 → 0.1
+    return Number(minDiff.toFixed(maxDecimals));
+}
+/**
+ * Get price precision (decimal places) from a price string.
+ */
+function pricePrecision(priceStr) {
+    return priceStr.includes(".") ? priceStr.split(".")[1].length : 0;
+}
+/**
+ * Check if an order response contains an embedded error (not thrown).
+ * Some exchanges (e.g., Hyperliquid) return success at HTTP level but include
+ * error statuses inside the response body.
+ */
+function hasOrderError(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    const r = result;
+    // Hyperliquid: { response: { data: { statuses: [{ error: "..." }] } } }
+    const resp = r.response;
+    const data = resp?.data;
+    const statuses = data?.statuses;
+    if (Array.isArray(statuses) && statuses.length > 0 && statuses[0].error)
+        return true;
+    // Generic: { ok: false } or { success: false }
+    if (r.ok === false || r.success === false)
+        return true;
+    return false;
+}
+/**
+ * Execute a smart order at best bid/ask + 1 tick.
+ * Drop-in replacement for `adapter.marketOrder()`.
+ */
+export async function smartOrder(adapter, symbol, side, size, opts = {}) {
+    const { tickTolerance = 1, fallback = true, reduceOnly = false } = opts;
+    // 1. Fetch orderbook
+    const book = await adapter.getOrderbook(symbol);
+    // 2. Validate book has liquidity on the relevant side
+    const relevantSide = side === "buy" ? book.asks : book.bids;
+    if (relevantSide.length === 0) {
+        if (!fallback)
+            throw new Error(`No ${side === "buy" ? "asks" : "bids"} in orderbook for ${symbol}`);
+        const result = await adapter.marketOrder(symbol, side, size);
+        return { result, method: "market_fallback", price: "0", bestBookPrice: "0", tickSize: "0" };
+    }
+    // 3. Get best price and tick size
+    const bestEntry = relevantSide[0];
+    const bestPrice = Number(bestEntry[0]);
+    const tick = inferTickSize(relevantSide);
+    const decimals = pricePrecision(bestEntry[0]);
+    // 4. Calculate limit price: best price + N ticks in favorable direction
+    const limitPrice = side === "buy"
+        ? bestPrice + tick * tickTolerance // 1 tick above best ask
+        : bestPrice - tick * tickTolerance; // 1 tick below best bid
+    const formattedPrice = limitPrice.toFixed(decimals);
+    // 5. Place IOC limit order at calculated price
+    try {
+        const result = await adapter.limitOrder(symbol, side, formattedPrice, size, {
+            tif: "IOC",
+            reduceOnly,
+        });
+        // Check for exchange-level rejection inside a "success" response
+        // (e.g., Hyperliquid returns { status: "ok", response: { data: { statuses: [{ error: "..." }] } } })
+        if (fallback && hasOrderError(result)) {
+            const fallbackResult = await adapter.marketOrder(symbol, side, size);
+            return {
+                result: fallbackResult,
+                method: "market_fallback",
+                price: formattedPrice,
+                bestBookPrice: bestEntry[0],
+                tickSize: tick.toFixed(decimals),
+            };
+        }
+        return {
+            result,
+            method: "limit_ioc",
+            price: formattedPrice,
+            bestBookPrice: bestEntry[0],
+            tickSize: tick.toFixed(decimals),
+        };
+    }
+    catch (err) {
+        if (!fallback)
+            throw err;
+        // Fallback to raw market order for reliability
+        const result = await adapter.marketOrder(symbol, side, size);
+        return {
+            result,
+            method: "market_fallback",
+            price: formattedPrice,
+            bestBookPrice: bestEntry[0],
+            tickSize: tick.toFixed(decimals),
+        };
+    }
+}

package/dist/trade-validator.js

@@ -1,5 +1,6 @@
 import { symbolMatch } from "./utils.js";
-const DEFAULT_TAKER_FEE = 0.0005; // 0.05%
+import { DEFAULT_TAKER_FEE } from "./constants.js";
+// Use centralized DEFAULT_TAKER_FEE from constants.ts (0.035%)
 const DEFAULT_MAX_SLIPPAGE = 0.005; // 0.5%
 /**
  * Validate a trade before execution.

package/dist/utils.js

@@ -107,7 +107,13 @@ export function printJson(data) {
         const fields = process.argv[fieldsArg + 1].split(",").map(f => f.trim());
         const envelope = output;
         if (envelope.ok && envelope.data && typeof envelope.data === "object") {
-            envelope.data = pickFields(envelope.data, fields);
+            // If data is an array, apply pickFields to each element
+            if (Array.isArray(envelope.data)) {
+                envelope.data = envelope.data.map((item) => pickFields(item, fields));
+            }
+            else {
+                envelope.data = pickFields(envelope.data, fields);
+            }
         }
         output = envelope;
     }

package/dist/ws/market-feed.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Unified market data feeds for CLI streaming commands.
+ *
+ * - Hyperliquid: native WebSocket (allMids, l2Book, trades, candle)
+ * - Lighter: REST polling (no public market data WS)
+ * - Pacifica: handled via existing PacificaWSClient in stream.ts
+ */
+import { EventEmitter } from "events";
+export interface PriceUpdate {
+    symbol: string;
+    mid: number;
+    funding?: number;
+}
+export interface BookUpdate {
+    bids: [string, string][];
+    asks: [string, string][];
+}
+export interface TradeUpdate {
+    side: string;
+    price: string;
+    size: string;
+    time: number;
+}
+export interface CandleUpdate {
+    o: string;
+    h: string;
+    l: string;
+    c: string;
+    v: string;
+    t: number;
+}
+export declare class HyperliquidMarketFeed extends EventEmitter {
+    private ws;
+    private closed;
+    private reconnectTimer;
+    private subs;
+    get wsUrl(): string;
+    connect(): Promise<void>;
+    private send;
+    private sub;
+    private scheduleReconnect;
+    subscribePrices(): void;
+    subscribeBook(symbol: string): void;
+    subscribeTrades(symbol: string): void;
+    subscribeCandle(symbol: string, interval: string): void;
+    private handleMessage;
+    close(): void;
+}
+export interface LighterFeedOpts {
+    /** Polling interval for prices in ms (default: 3000) */
+    pricesIntervalMs?: number;
+    /** Polling interval for book/trades in ms (default: 2000) */
+    bookIntervalMs?: number;
+    /** Polling interval for candles in ms (default: 5000) */
+    candleIntervalMs?: number;
+}
+export declare class LighterMarketFeed extends EventEmitter {
+    private closed;
+    private timers;
+    private marketMap;
+    private pricesMs;
+    private bookMs;
+    private candleMs;
+    constructor(opts?: LighterFeedOpts);
+    connect(): Promise<void>;
+    private getMarketId;
+    private poll;
+    subscribePrices(): void;
+    subscribeBook(symbol: string): void;
+    subscribeTrades(symbol: string): void;
+    subscribeCandle(symbol: string, interval: string): void;
+    close(): void;
+}
+export declare function createMarketFeed(exchange: string): HyperliquidMarketFeed | LighterMarketFeed;