perp-cli 0.14.3 → 0.16.0

package/dist/index.js

@@ -17,6 +17,7 @@ import { createRequire } from "node:module";
 config({ path: resolve(process.env.HOME || "~", ".perp", ".env") });
 import chalk from "chalk";
 import { listVenues } from "./exchanges/venue.js";
+import { optionsVenueWords } from "./exchanges/options-venues.js";
 import { PerpError } from "./errors.js";
 import { loadSettings } from "./settings.js";
 import { jsonError, jsonOk, printCliError, printJson } from "./utils.js";
@@ -49,7 +50,7 @@ const _defaultExchange = _settings.defaultExchange || "pacifica";
 const { program, getAdapterForExchange, isJson } = buildProgram({ defaultExchange: _defaultExchange, version: _pkg.version });
 // Smart landing page: `perp` with no subcommand
 const rawArgs = process.argv.slice(2);
-const _venueWords = listVenues().flatMap(v => [v.id, ...v.aliases]);
+const _venueWords = [...listVenues().flatMap(v => [v.id, ...v.aliases]), ...optionsVenueWords()];
 const hasSubcommand = rawArgs.some((a) => !a.startsWith("-") && ![..._venueWords, "mainnet", "testnet"].includes(a));
 // `history list -n 5` (old record-count flag) → INVALID_PARAMS with the --limit migration, before
 // Commander turns it into a bare "invalid network" usage error.
@@ -118,18 +119,18 @@ if (rawArgs.length === 0 || (!hasSubcommand && !rawArgs.includes("-h") && !rawAr
                     const landingVenues = [];
                     for (const ex of LANDING_EXCHANGES) {
                         const def = getVenue(ex);
-                        if (def.create === null || await hasCredentials(def.id, NO_CLI_CREDENTIAL_OPTS))
+                        if (!def.roles.includes("account") || await hasCredentials(def.id, NO_CLI_CREDENTIAL_OPTS))
                             landingVenues.push(ex);
                     }
                     const statusResults = await Promise.allSettled(landingVenues.map(async (ex) => {
-                        if (getVenue(ex).create === null) {
-                            return { exchange: ex, marketDataOnly: true, ok: false, equity: 0, positions: 0 };
+                        if (!getVenue(ex).roles.includes("account")) {
+                            return { exchange: ex, marketDataOnly: true, unofficialApi: getVenue(ex).apiStatus.kind === "unofficial", ok: false, equity: 0, positions: 0 };
                         }
                         try {
                             const adapter = await withTimeout(getAdapterForExchange(ex), 5000);
                             const [balance, positions] = await withTimeout(Promise.all([adapter.getBalance(), adapter.getPositions()]), 5000);
                             const posCount = positions.filter(p => Number(p.size) > 0).length;
-                            // Spot value on top of perp equity for venues with def.spot (§12). Shared balances
+                            // Spot value on top of perp equity for venues with def.spot. Shared balances
                             // (already in perp equity) are skipped; unpriced tokens are excluded + warned.
                             let spotValue = 0;
                             const spotDef = getVenue(ex);
@@ -196,7 +197,7 @@ else {
     }).catch(async (err) => {
         // Central printer (utils.printCliError): typed PerpError code / remediation / details
         // are preserved (Rule #2: stay loud, keep semantic envelope); generic Errors go
-        // through classifyError; CAPABILITY_UNSUPPORTED prints the uniform §13.6 line.
+        // through classifyError; CAPABILITY_UNSUPPORTED prints the uniform line.
         const { printCliError } = await import("./utils.js");
         printCliError(err, isJson());
         _origExit(1);

package/dist/jobs.d.ts

@@ -1,5 +1,6 @@
 import type { Command } from "commander";
 import type { Network } from "./exchanges/venue-types.js";
+import "./exchanges/venues/index.js";
 export interface JobEntry {
     id: string;
     strategy: string;

package/dist/jobs.js

@@ -4,9 +4,11 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { randomBytes } from "node:crypto";
 import { parse as parseDotenv } from "dotenv";
+import { getVenue, roleUnsupported, tryResolveVenueId } from "./exchanges/venue.js";
+import "./exchanges/venues/index.js";
 import { PerpError } from "./errors.js";
 import { QFEX_AUTOMATION_VERIFIED, QFEX_REDUCE_ONLY_WIRE, qfexAutomationGate, qfexReduceOnlyGate } from "./exchanges/qfex/signing.js";
-import { startRefusal } from "./exchanges/trading-v2.js";
+import { startRefusal, unsupported } from "./exchanges/trading-v2.js";
 import { scrubSecretEnv, secretEnvNamesIn } from "./secret-env.js";
 const JOBS_DIR = join(homedir(), ".perp", "jobs");
 const LOGS_DIR = join(homedir(), ".perp", "logs");
@@ -165,6 +167,28 @@ export function startJob(opts) {
             if (automation !== null)
                 throw startRefusal(what, "it would trade unattended", automation);
         }
+        for (const v of new Set([opts.venue, opts.exchange])) {
+            const id = v?.toLowerCase();
+            const what = `Background job "${opts.strategy}"`;
+            // RISEx: unattended trading stays off until its trading path is verified on mainnet (no TP/SL yet).
+            if (id === "risex" || id === "rise") {
+                // Read-only release (trading role gated): the uniform phase refusal.
+                const risex = getVenue("risex");
+                if (!risex.roles.includes("trading"))
+                    throw startRefusal(what, "it would trade unattended", roleUnsupported(risex, "automation"));
+                throw startRefusal(what, "it would trade unattended", unsupported("RISEx", "automation", "unattended trading on RISEx is not enabled until its trading path is verified on mainnet (and it has no TP/SL yet)", "Trade RISEx manually with perp trade …"));
+            }
+            // TxFlow: market data only (unofficial read-only API).
+            if (id === "txflow" || id === "txf") {
+                throw startRefusal(what, "TxFlow has no trading in perp-cli", unsupported("txflow", "trading", "TxFlow is integrated through an unofficial read-only API (market data only)", "Trade on the TxFlow website"));
+            }
+            // Any other registered venue without the trading role (Variational, GRVT, Extended: read-only in this version).
+            const venueId = id === undefined ? null : tryResolveVenueId(id);
+            if (venueId !== null && !getVenue(venueId).roles.includes("trading")) {
+                const def = getVenue(venueId);
+                throw startRefusal(what, `${def.displayName} has no trading in perp-cli`, roleUnsupported(def, "trading"));
+            }
+        }
     }
     if (!hasTmux()) {
         throw new Error("tmux is required for background jobs. Install with: brew install tmux");

package/dist/landing.d.ts

@@ -5,6 +5,8 @@ export type LandingExchangeStatus = {
     exchange: string;
     /** Venue has no account API — rendered as market data only. */
     marketDataOnly?: boolean;
+    /** Venue is read through an undocumented API (VenueDefinition.apiStatus) — labelled "unofficial API". */
+    unofficialApi?: boolean;
     ok: boolean;
     equity: number;
     positions: number;

package/dist/landing.js

@@ -25,7 +25,7 @@ export function renderLandingExchangeLine(status, asterAgentMissing) {
         return `    ${chalk.yellow("⚙")} ${chalk.cyan(exchangeLabel(status.exchange).padEnd(14))} ${chalk.yellow("agent required")} ${chalk.gray("→ perp wallet agent approve aster")}`;
     }
     if (status.marketDataOnly) {
-        return `    ${chalk.gray("◇")} ${chalk.cyan(exchangeLabel(status.exchange).padEnd(14))} ${chalk.gray("market data only")}`;
+        return `    ${chalk.gray("◇")} ${chalk.cyan(exchangeLabel(status.exchange).padEnd(14))} ${chalk.gray("market data only")}${status.unofficialApi ? chalk.yellow(" (unofficial API)") : ""}`;
     }
     const icon = status.ok ? chalk.green("●") : chalk.red("○");
     const equity = status.ok

package/dist/liquidity.d.ts

@@ -26,7 +26,9 @@ export declare function computeExecutableSize(levels: [string, string][], reques
  * Check liquidity on both sides for an arb entry.
  * Returns adjusted size or 0 if not viable.
  */
-export declare function checkArbLiquidity(longAdapter: ExchangeAdapter, shortAdapter: ExchangeAdapter, symbol: string, sizeUsd: number, maxSlippagePct?: number, log?: (msg: string) => void): Promise<{
+export declare function checkArbLiquidity(longAdapter: ExchangeAdapter, shortAdapter: ExchangeAdapter, symbol: string, sizeUsd: number, maxSlippagePct?: number, log?: (msg: string) => void, 
+/** The short venue's own symbol when it differs (kPEPE ↔ 1000PEPE); default `symbol`. */
+shortSymbol?: string): Promise<{
     viable: boolean;
     adjustedSizeUsd: number;
     longSlippage: number;

package/dist/liquidity.js

@@ -1,3 +1,4 @@
+import { classifyError } from "./errors.js";
 /**
  * Walk through orderbook levels and compute how much can be filled
  * within the given slippage tolerance.
@@ -63,11 +64,13 @@ export function computeExecutableSize(levels, requestedSizeUsd, maxSlippagePct =
  * Check liquidity on both sides for an arb entry.
  * Returns adjusted size or 0 if not viable.
  */
-export async function checkArbLiquidity(longAdapter, shortAdapter, symbol, sizeUsd, maxSlippagePct = 0.5, log) {
+export async function checkArbLiquidity(longAdapter, shortAdapter, symbol, sizeUsd, maxSlippagePct = 0.5, log, 
+/** The short venue's own symbol when it differs (kPEPE ↔ 1000PEPE); default `symbol`. */
+shortSymbol = symbol) {
     try {
         const [longOB, shortOB] = await Promise.all([
             longAdapter.getOrderbook(symbol),
-            shortAdapter.getOrderbook(symbol),
+            shortAdapter.getOrderbook(shortSymbol),
         ]);
         // For long entry we consume asks, for short entry we consume bids
         const longCheck = computeExecutableSize(longOB.asks, sizeUsd, maxSlippagePct);
@@ -145,8 +148,9 @@ export async function checkSpotPerpLiquidity(spotAdapter, perpAdapter, spotSymbo
             perpSlippage: perpCheck.slippagePct,
         };
     }
-    catch {
-        log?.(`[LIQ] spot-perp ${spotSymbol}: orderbook fetch failed`);
+    catch (e) {
+        const c = classifyError(e);
+        log?.(`[LIQ] spot-perp ${spotSymbol}: orderbook fetch failed (${c.code}: ${c.message})`);
         return { viable: false, adjustedSizeUsd: 0, spotSlippage: 0, perpSlippage: 0 };
     }
 }

package/dist/mcp-pacifica-earn.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read-only MCP tools for Pacifica Print and vaults (unauthenticated GETs; nothing is signed).
+ * Print deposits / ends and vault deposits / withdrawals are NOT exposed over MCP: the server has
+ * no money-moving deposit / withdraw tools (funds moves are CLI-only, `perp funds …`), and these
+ * follow the same rule — use `perp print deposit` / `perp vault deposit|withdraw` (with --dry-run).
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Network } from "./exchanges/venue-types.js";
+export declare function registerPacificaEarnMcpTools(server: McpServer, network: Network, ok: (data: unknown, meta?: Record<string, unknown>) => string, errOf: (e: unknown, meta?: Record<string, unknown>) => string): void;

package/dist/mcp-pacifica-earn.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { PacificaClient, requireSolanaAddress } from "./pacifica/client.js";
+import { fetchPrintGames, fetchPrintHistory, fetchPrintMarket, fetchPrintPositions, findPrintGame, quotePrintOrder } from "./exchanges/pacifica-print.js";
+import { DEPOSIT_WHITELIST_API_STATUS, readDepositWhitelist, fetchVaults, findVault, heldShares, withdrawWindowAt } from "./exchanges/pacifica-vaults.js";
+export function registerPacificaEarnMcpTools(server, network, ok, errOf) {
+    const client = () => new PacificaClient({ network });
+    const run = async (meta, f) => {
+        try {
+            return { content: [{ type: "text", text: ok(await f(), meta) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: errOf(e, meta) }], isError: true };
+        }
+    };
+    const address = z.string().refine((v) => { try {
+        requireSolanaAddress(v);
+        return true;
+    }
+    catch {
+        return false;
+    } }, "base58 Solana address (32-byte public key; not an EVM address)");
+    server.tool("pacifica_print_products", "Pacifica Print products (read-only): game id (e.g. BTC_24H, BTC_7D, BTC_1M), cycle length in days, max leverage, deposit caps, allowed target distance from mark. Print = a strike order that earns a premium each cycle; while resting it fills / is liquidated only at a cycle checkpoint, after a fill it is an ordinary perp position (continuous liquidation).", {}, async () => run({ exchange: "pacifica" }, async () => fetchPrintGames(client())));
+    server.tool("pacifica_print_quote", "Validate a Pacifica Print order and preview it (read-only, nothing signed): notional, size on fill, docs-formula liquidation price (an outer bound — a liquidation was observed earlier in one live case; venue trigger unpublished), max loss (deposit + premiums), lock period. The premium is not quoted (the venue's preview is a signed request). Placing the order is CLI-only: perp -e pacifica print deposit … (supports --dry-run).", {
+        game: z.string().describe("Print product, e.g. BTC_24H"),
+        direction: z.enum(["long", "short"]).describe("long = target below mark, short = target above mark"),
+        deposit: z.string().describe("USDC deposit, min 10"),
+        strike: z.string().describe("Target price (on the market tick)"),
+        leverage: z.string().describe("Whole-number leverage 1 … product max"),
+        cycles: z.number().int().optional().describe("Cycles 1 … 1000; omit = roll until cancelled"),
+    }, async ({ game, direction, deposit, strike, leverage, cycles }) => run({ exchange: "pacifica", game }, async () => {
+        const c = client();
+        const g = findPrintGame(await fetchPrintGames(c), game);
+        return quotePrintOrder(g, { game: g.game, direction, deposit, strikePrice: strike, leverage, cycles: cycles ?? null }, await fetchPrintMarket(c, g.asset));
+    }));
+    server.tool("pacifica_print_positions", "Pacifica Print orders of an account (read-only): current orders, or with history=true every order (paginated: limit / cursor). Status printing | cancelling | filled | liquidated | cancelled | completed | ended.", {
+        account: address.describe("Pacifica account (Solana address)"),
+        history: z.boolean().optional().describe("true = every order (history_summary), default false = current orders"),
+        limit: z.number().int().positive().optional(),
+        cursor: z.string().optional(),
+    }, async ({ account, history, limit, cursor }) => run({ exchange: "pacifica", account }, async () => {
+        if (history !== true)
+            return { account, positions: await fetchPrintPositions(client(), account) };
+        const page = await fetchPrintHistory(client(), account, { limit: limit ?? null, cursor: cursor ?? null });
+        return { account, positions: page.items, hasMore: page.hasMore, nextCursor: page.nextCursor };
+    }));
+    server.tool("pacifica_vaults", "Pacifica vaults (API: lakes), read-only. Without vault: every vault (TVL, NAV per share, fee, lock-up, withdrawal window, config); with account: plus that account's shares. With vault (address, or a nickname matching exactly one vault — an ambiguous nickname is INVALID_PARAMS listing the candidates): one vault plus live account equity, positions, deposit whitelist (unofficial endpoint, advisory) and whether withdrawals are open now. APY is not published (null). Deposits / withdrawals are CLI-only: perp -e pacifica vault deposit|withdraw (supports --dry-run).", {
+        vault: z.string().optional().describe("Vault address or exact nickname"),
+        account: address.optional().describe("Include this account's shares"),
+    }, async ({ vault, account }) => run({ exchange: "pacifica" }, async () => {
+        const c = client();
+        const vaults = await fetchVaults(c, account ?? null);
+        if (vault === undefined)
+            return vaults;
+        const v = findVault(vaults, vault);
+        const [acct, positions, whitelist] = await Promise.all([c.getAccount(v.address), c.getPositions(v.address), readDepositWhitelist(c, v.address)]);
+        return {
+            ...v,
+            ...(account !== undefined ? { holding: heldShares(v, account) } : {}),
+            live: { accountEquity: acct.account_equity ?? null, availableToWithdraw: acct.available_to_withdraw ?? null, positions: positions.map((p) => ({ symbol: p.symbol, side: p.side, amount: p.amount, entryPrice: p.entry_price })) },
+            depositWhitelist: { apiStatus: DEPOSIT_WHITELIST_API_STATUS, addresses: whitelist.addresses, error: whitelist.error },
+            withdrawWindow: withdrawWindowAt(v.config, Date.now()),
+        };
+    }));
+}