perp-cli 0.3.3

package/dist/exchanges/pacifica.d.ts

@@ -0,0 +1,51 @@
+import { Keypair } from "@solana/web3.js";
+import { PacificaClient, type Network } from "../pacifica/index.js";
+import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
+export declare class PacificaAdapter implements ExchangeAdapter {
+    readonly name = "pacifica";
+    private client;
+    readonly keypair: Keypair;
+    private account;
+    private signMessage;
+    constructor(keypair: Keypair, network?: Network, builderCode?: string);
+    private _getPrices;
+    private _getPositions;
+    get publicKey(): string;
+    get sdk(): PacificaClient;
+    get signer(): (msg: Uint8Array) => Promise<Uint8Array>;
+    getMarkets(): Promise<ExchangeMarketInfo[]>;
+    getOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getBalance(): Promise<ExchangeBalance>;
+    getPositions(): Promise<ExchangePosition[]>;
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
+        reduceOnly?: boolean;
+        tif?: string;
+    }): Promise<unknown>;
+    cancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    cancelAllOrders(_symbol?: string): Promise<unknown>;
+    editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
+    setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<{
+        symbol: string;
+        leverage: number;
+        marginMode: "cross" | "isolated";
+    }>;
+    stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
+        limitPrice?: string;
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
+    getRecentTrades(symbol: string, _limit?: number): Promise<ExchangeTrade[]>;
+    getFundingHistory(symbol: string, limit?: number): Promise<{
+        time: number;
+        rate: string;
+        price: string;
+    }[]>;
+    getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
+    getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
+}

package/dist/exchanges/pacifica.js

@@ -0,0 +1,248 @@
+import nacl from "tweetnacl";
+import { PacificaClient } from "../pacifica/index.js";
+function makeSignMessage(keypair) {
+    return async (message) => {
+        return nacl.sign.detached(message, keypair.secretKey);
+    };
+}
+export class PacificaAdapter {
+    name = "pacifica";
+    client;
+    keypair;
+    account;
+    signMessage;
+    // In-memory caches removed — using file-based cache (src/cache.ts) for cross-process dedup
+    constructor(keypair, network = "mainnet", builderCode) {
+        this.keypair = keypair;
+        this.account = keypair.publicKey.toBase58();
+        this.client = new PacificaClient({ network, builderCode });
+        this.signMessage = makeSignMessage(keypair);
+    }
+    async _getPrices() {
+        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
+        return fetchAndCache(`acct:pac:prices:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPrices());
+    }
+    async _getPositions() {
+        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
+        return fetchAndCache(`acct:pac:positions:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPositions(this.account));
+    }
+    get publicKey() {
+        return this.account;
+    }
+    get sdk() {
+        return this.client;
+    }
+    get signer() {
+        return this.signMessage;
+    }
+    async getMarkets() {
+        const [markets, prices] = await Promise.all([
+            this.client.getInfo(),
+            this._getPrices(),
+        ]);
+        const priceMap = new Map(prices.map((p) => [p.symbol, p]));
+        return markets.map((m) => {
+            const p = priceMap.get(m.symbol);
+            return {
+                symbol: m.symbol,
+                markPrice: p?.mark ?? "-",
+                indexPrice: p?.oracle ?? "-",
+                fundingRate: m.next_funding_rate ?? m.funding_rate,
+                volume24h: p?.volume_24h ?? "-",
+                openInterest: p?.open_interest ?? "-",
+                maxLeverage: m.max_leverage,
+            };
+        });
+    }
+    async getOrderbook(symbol) {
+        const book = await this.client.getBook(symbol);
+        return {
+            bids: book.l[0].map((e) => [e.p, e.a]),
+            asks: book.l[1].map((e) => [e.p, e.a]),
+        };
+    }
+    async getBalance() {
+        const [info, positions, prices] = await Promise.all([
+            this.client.getAccount(this.account),
+            this._getPositions(),
+            this._getPrices(),
+        ]);
+        const raw = info;
+        const priceMap = new Map(prices.map((p) => [p.symbol, Number(p.mark)]));
+        // Sum actual unrealized PnL from positions (mark vs entry)
+        let totalPnl = 0;
+        for (const p of positions) {
+            const mark = priceMap.get(p.symbol) ?? 0;
+            const entry = Number(p.entry_price);
+            const amount = Number(p.amount);
+            const side = p.side === "bid" ? "long" : "short";
+            totalPnl += side === "long"
+                ? (mark - entry) * amount
+                : (entry - mark) * amount;
+        }
+        return {
+            equity: info.account_equity,
+            available: info.available_to_spend,
+            marginUsed: String(raw.total_margin_used ?? raw.margin_used ?? "0"),
+            unrealizedPnl: totalPnl.toFixed(4),
+        };
+    }
+    async getPositions() {
+        const [positions, prices] = await Promise.all([
+            this._getPositions(),
+            this._getPrices(),
+        ]);
+        const priceMap = new Map(prices.map((p) => [p.symbol, p]));
+        let levMap = new Map();
+        try {
+            const settings = await this.client.getAccountSettings(this.account);
+            if (Array.isArray(settings)) {
+                levMap = new Map(settings.map((s) => [s.symbol, s.leverage]));
+            }
+        }
+        catch {
+            // Settings API may not be available
+        }
+        return positions.map((p) => {
+            const mark = priceMap.get(p.symbol)?.mark ?? "0";
+            const entryPrice = Number(p.entry_price);
+            const amount = Number(p.amount);
+            const markNum = Number(mark);
+            const side = p.side === "bid" ? "long" : "short";
+            const pnl = side === "long"
+                ? (markNum - entryPrice) * amount
+                : (entryPrice - markNum) * amount;
+            return {
+                symbol: p.symbol,
+                side: side,
+                size: String(p.amount),
+                entryPrice: String(p.entry_price),
+                markPrice: mark,
+                liquidationPrice: String(p.liquidation_price ?? "N/A"),
+                unrealizedPnl: pnl.toFixed(4),
+                leverage: levMap.get(String(p.symbol)) ?? 1,
+            };
+        });
+    }
+    async getOpenOrders() {
+        const orders = await this.client.getOrders(this.account);
+        return orders.map((o) => {
+            const raw = o;
+            return {
+                orderId: String(raw.order_id),
+                symbol: String(raw.symbol),
+                side: raw.side === "bid" ? "buy" : "sell",
+                price: String(raw.price),
+                size: String(raw.initial_amount ?? raw.amount ?? ""),
+                filled: String(raw.filled_amount ?? raw.filled ?? "0"),
+                status: String(raw.order_status ?? "open"),
+                type: String(raw.order_type ?? ""),
+            };
+        });
+    }
+    async marketOrder(symbol, side, size) {
+        return this.client.createMarketOrder({ symbol, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: false, slippage_percent: "1" }, this.account, this.signMessage);
+    }
+    async limitOrder(symbol, side, price, size, opts) {
+        return this.client.createLimitOrder({ symbol, price, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts?.reduceOnly ?? false, tif: (opts?.tif ?? "GTC") }, this.account, this.signMessage);
+    }
+    async cancelOrder(symbol, orderId) {
+        return this.client.cancelOrder({ symbol, order_id: Number(orderId) }, this.account, this.signMessage);
+    }
+    async cancelAllOrders(_symbol) {
+        return this.client.cancelAllOrders({ all_symbols: true, exclude_reduce_only: false }, this.account, this.signMessage);
+    }
+    async editOrder(symbol, orderId, price, size) {
+        return this.client.editOrder({ symbol, order_id: Number(orderId), price, amount: size }, this.account, this.signMessage);
+    }
+    async setLeverage(symbol, leverage, marginMode = "cross") {
+        await this.client.updateLeverage({ symbol, leverage }, this.account, this.signMessage);
+        if (marginMode === "isolated") {
+            await this.client.updateMarginMode({ symbol, is_isolated: true }, this.account, this.signMessage);
+        }
+        return { symbol, leverage, marginMode };
+    }
+    async stopOrder(symbol, side, size, triggerPrice, opts) {
+        return this.client.createStopOrder({
+            symbol,
+            side: side === "buy" ? "bid" : "ask",
+            reduce_only: opts?.reduceOnly ?? false,
+            stop_order: { stop_price: triggerPrice, amount: size, limit_price: opts?.limitPrice },
+        }, this.account, this.signMessage);
+    }
+    async getRecentTrades(symbol, _limit = 20) {
+        const trades = await this.client.getTrades(symbol);
+        return trades.slice(0, _limit).map((t) => ({
+            time: new Date(t.created_at).getTime(),
+            symbol,
+            side: t.side === "bid" ? "buy" : "sell",
+            price: t.price,
+            size: t.amount,
+            fee: "0",
+        }));
+    }
+    async getFundingHistory(symbol, limit = 10) {
+        const result = await this.client.getFundingHistory(symbol, { limit });
+        const data = (result.data ?? result);
+        if (!Array.isArray(data))
+            return [];
+        return data.map((h) => ({
+            time: Number(h.created_at ?? 0),
+            rate: String(h.funding_rate ?? "0"),
+            price: String(h.oracle_price ?? "0"),
+        }));
+    }
+    async getKlines(symbol, interval, startTime, endTime) {
+        const klines = await this.client.getKline(symbol, interval, startTime, endTime);
+        return klines.map((k) => ({
+            time: k.t,
+            open: k.o,
+            high: k.h,
+            low: k.l,
+            close: k.c,
+            volume: k.v,
+            trades: k.n,
+        }));
+    }
+    async getOrderHistory(limit = 30) {
+        const result = await this.client.getOrderHistory(this.account);
+        const data = (result.data ?? result.orders ?? []);
+        if (!Array.isArray(data))
+            return [];
+        return data.slice(0, limit).map((o) => ({
+            orderId: String(o.order_id ?? ""),
+            symbol: String(o.symbol ?? ""),
+            side: String(o.side) === "bid" ? "buy" : "sell",
+            price: String(o.initial_price ?? o.price ?? "0"),
+            size: String(o.amount ?? o.initial_amount ?? ""),
+            filled: String(o.filled_amount ?? "0"),
+            status: String(o.order_status ?? "done"),
+            type: String(o.order_type ?? ""),
+        }));
+    }
+    async getTradeHistory(limit = 30) {
+        const raw = await this.client.getTradeHistory(this.account);
+        const trades = (raw.data ?? raw);
+        if (!Array.isArray(trades))
+            return [];
+        return trades.slice(0, limit).map((t) => ({
+            time: Number(t.created_at ?? 0),
+            symbol: String(t.symbol ?? ""),
+            side: String(t.side) === "bid" ? "buy" : "sell",
+            price: String(t.price ?? "0"),
+            size: String(t.amount ?? ""),
+            fee: String(t.fee ?? "0"),
+        }));
+    }
+    async getFundingPayments(limit = 30) {
+        const raw = await this.client.getFundingAccountHistory(this.account);
+        const history = (raw.data ?? raw);
+        if (!Array.isArray(history))
+            return [];
+        return history.slice(0, limit).map((h) => ({
+            time: Number(h.created_at ?? 0),
+            symbol: String(h.symbol ?? ""),
+            payment: String(h.amount ?? "0"),
+        }));
+    }
+}

package/dist/execution-log.d.ts

@@ -0,0 +1,36 @@
+export interface ExecutionRecord {
+    id: string;
+    timestamp: string;
+    type: "market_order" | "limit_order" | "cancel" | "stop_order" | "edit_order" | "rebalance" | "arb_entry" | "arb_close" | "bridge";
+    exchange: string;
+    symbol: string;
+    side: string;
+    size: string;
+    price?: string;
+    notional?: number;
+    status: "success" | "failed" | "simulated";
+    error?: string;
+    meta?: Record<string, unknown>;
+    dryRun: boolean;
+}
+/** Append an execution record to the log */
+export declare function logExecution(record: Omit<ExecutionRecord, "id" | "timestamp">): ExecutionRecord;
+/** Read execution log with optional filters */
+export declare function readExecutionLog(opts?: {
+    limit?: number;
+    exchange?: string;
+    symbol?: string;
+    type?: string;
+    since?: string;
+    dryRunOnly?: boolean;
+}): ExecutionRecord[];
+/** Get execution stats summary */
+export declare function getExecutionStats(since?: string): {
+    totalTrades: number;
+    successRate: number;
+    byExchange: Record<string, number>;
+    byType: Record<string, number>;
+    recentErrors: string[];
+};
+/** Clear old records (keep last N days) */
+export declare function pruneExecutionLog(keepDays?: number): number;

package/dist/execution-log.js

@@ -0,0 +1,102 @@
+import { existsSync, appendFileSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
+const LOG_FILE = resolve(PERP_DIR, "executions.jsonl");
+function ensureDir() {
+    if (!existsSync(PERP_DIR))
+        mkdirSync(PERP_DIR, { recursive: true, mode: 0o700 });
+}
+function genId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Append an execution record to the log */
+export function logExecution(record) {
+    ensureDir();
+    const full = {
+        id: genId(),
+        timestamp: new Date().toISOString(),
+        ...record,
+    };
+    appendFileSync(LOG_FILE, JSON.stringify(full) + "\n", { mode: 0o600 });
+    return full;
+}
+/** Read execution log with optional filters */
+export function readExecutionLog(opts) {
+    if (!existsSync(LOG_FILE))
+        return [];
+    const lines = readFileSync(LOG_FILE, "utf-8").trim().split("\n").filter(Boolean);
+    let records = lines.map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    }).filter(Boolean);
+    // Apply filters
+    if (opts?.exchange) {
+        records = records.filter(r => r.exchange === opts.exchange);
+    }
+    if (opts?.symbol) {
+        records = records.filter(r => r.symbol.toUpperCase().includes(opts.symbol.toUpperCase()));
+    }
+    if (opts?.type) {
+        records = records.filter(r => r.type === opts.type);
+    }
+    if (opts?.since) {
+        const sinceDate = new Date(opts.since).getTime();
+        records = records.filter(r => new Date(r.timestamp).getTime() >= sinceDate);
+    }
+    if (opts?.dryRunOnly) {
+        records = records.filter(r => r.dryRun);
+    }
+    // Sort newest first
+    records.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    // Limit
+    if (opts?.limit) {
+        records = records.slice(0, opts.limit);
+    }
+    return records;
+}
+/** Get execution stats summary */
+export function getExecutionStats(since) {
+    const records = readExecutionLog({ since });
+    const successful = records.filter(r => r.status === "success");
+    const byExchange = {};
+    const byType = {};
+    const recentErrors = [];
+    for (const r of records) {
+        byExchange[r.exchange] = (byExchange[r.exchange] || 0) + 1;
+        byType[r.type] = (byType[r.type] || 0) + 1;
+        if (r.status === "failed" && r.error && recentErrors.length < 5) {
+            recentErrors.push(`[${r.exchange}] ${r.error}`);
+        }
+    }
+    return {
+        totalTrades: records.length,
+        successRate: records.length > 0 ? (successful.length / records.length) * 100 : 0,
+        byExchange,
+        byType,
+        recentErrors,
+    };
+}
+/** Clear old records (keep last N days) */
+export function pruneExecutionLog(keepDays = 30) {
+    if (!existsSync(LOG_FILE))
+        return 0;
+    const lines = readFileSync(LOG_FILE, "utf-8").trim().split("\n").filter(Boolean);
+    const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1000;
+    const kept = lines.filter(line => {
+        try {
+            const r = JSON.parse(line);
+            return new Date(r.timestamp).getTime() >= cutoff;
+        }
+        catch {
+            return false;
+        }
+    });
+    const pruned = lines.length - kept.length;
+    ensureDir();
+    writeFileSync(LOG_FILE, kept.join("\n") + (kept.length > 0 ? "\n" : ""), { mode: 0o600 });
+    return pruned;
+}

package/dist/funding/history.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Historical funding rate tracking.
+ *
+ * Stores funding rate snapshots as JSONL files in ~/.perp/funding-rates/
+ * organized by month (YYYY-MM.jsonl). Provides averaging and trend analysis
+ * over configurable time windows.
+ */
+import type { ExchangeFundingRate } from "./rates.js";
+export interface FundingHistoryEntry {
+    ts: string;
+    symbol: string;
+    exchange: string;
+    rate: number;
+    hourlyRate: number;
+}
+export interface HistoricalAverages {
+    avg1h: number | null;
+    avg8h: number | null;
+    avg24h: number | null;
+    avg7d: number | null;
+}
+export declare function cleanupOldFiles(): void;
+export declare function _resetCleanupFlag(): void;
+/**
+ * Save current funding rates as a historical snapshot.
+ * Deduplicates: skips entries if same symbol+exchange was saved within 5 minutes.
+ */
+export declare function saveFundingSnapshot(rates: ExchangeFundingRate[]): void;
+/**
+ * Get average funding rate for a symbol+exchange over the last N hours.
+ * Returns null if no data available.
+ */
+export declare function getAvgFundingRate(symbol: string, exchange: string, hours: number): number | null;
+/**
+ * Get all historical rates for a symbol+exchange in a time range.
+ */
+export declare function getHistoricalRates(symbol: string, exchange: string, startTime: Date, endTime: Date): {
+    ts: string;
+    rate: number;
+    hourlyRate: number;
+}[];
+/**
+ * Get averaged rates for all symbols across time windows.
+ * Returns a Map with key format "SYMBOL:exchange".
+ */
+export declare function getHistoricalAverages(symbols: string[], exchanges: string[]): Map<string, HistoricalAverages>;
+/**
+ * Calculate effective annualized return considering compounding frequency.
+ *
+ * All three main exchanges (HL, PAC, LT) compound every 1h (8760 times/year).
+ *
+ * Formula: (1 + rate)^(8760/compoundingHours) - 1
+ *
+ * @param hourlyRate - the per-hour funding rate
+ * @param compoundingHours - how often the exchange compounds (1 for all main exchanges)
+ * @returns effective annualized return as a decimal (not percentage)
+ */
+export declare function getCompoundedAnnualReturn(hourlyRate: number, compoundingHours: number): number;
+/**
+ * Get the compounding hours for an exchange.
+ * All main exchanges (HL, PAC, LT) compound every 1h.
+ */
+export declare function getExchangeCompoundingHours(exchange: string): number;