perp-cli 0.12.10 → 0.12.12

package/dist/commands/alerts.js

@@ -271,7 +271,7 @@ export function registerAlertCommands(program, isJson) {
             // Pass through env vars for keys
             // L2 agent key + indices now live in ~/.perp keystore + settings.agents (SSOT Rule #3),
             // not env. Only Tier 3 master PKs need passthrough.
-            const envKeys = ["LIGHTER_PRIVATE_KEY", "HL_PRIVATE_KEY", "PACIFICA_PRIVATE_KEY", "PRIVATE_KEY"];
+            const envKeys = ["LIGHTER_PRIVATE_KEY", "HL_PRIVATE_KEY", "PACIFICA_PRIVATE_KEY", "ASTER_PRIVATE_KEY", "PRIVATE_KEY"];
             const envStr = envKeys.filter(k => process.env[k]).map(k => `${k}='${process.env[k]}'`).join(" ");
             const cmd = `${envStr} ${nodeCmd} ${cliPath} ${args}`;
             execSync(`tmux new-session -d -s ${session} '${cmd.replace(/'/g, "'\\''")}'`);

package/dist/commands/manage.js

@@ -239,8 +239,7 @@ export function registerWalletManageCommands(parent, getAdapter, isJson, getPaci
     // Legacy `manage setup-api-key` removed in v0.12 (Phase 2d) — superseded by
     // the unified `wallet agent approve lighter` flow. The agent flow provides
     // 3-tier signer routing, expiry tracking, free-slot picking, and AgentMeta
-    // persistence. The auto-setup path in LighterAdapter.init() remains as the
-    // env-key fallback for users who haven't run the unified command yet.
+    // persistence.
     // ── Hyperliquid account abstraction mode ────────────────────────────────
     // Read side: HyperliquidAdapter._getAbstractionMode() (added v0.12.7).
     // Write side: HL `userSetAbstraction` action — master EVM EIP-712 signature.

package/dist/commands/wallet.js

@@ -1270,12 +1270,19 @@ export function registerWalletCommands(program, isJson, getAdapter, getPacificaA
         .option("--policy <ids>", "Comma-separated policy IDs to enforce")
         .option("--expires <iso>", "Key expiry (ISO-8601)")
         .option("-p, --passphrase <pass>", "Vault passphrase", "")
-        .action(async (opts) => {
+        .action(async (opts, command) => {
         try {
             const o = loadOws();
             const walletIds = opts.wallets.split(",").map(s => s.trim());
             const policyIds = opts.policy ? opts.policy.split(",").map(s => s.trim()) : [];
-            const result = o.createApiKey(opts.name, walletIds, policyIds, opts.passphrase, opts.expires);
+            // optsWithGlobals() merges parent + subcommand options, so --passphrase
+            // works whether placed on `perp --passphrase X wallet key create` (parent)
+            // or `perp wallet key create --passphrase X` (subcommand). Without this
+            // merge, Commander v13 silently shadows the subcommand flag with the
+            // parent flag and opts.passphrase becomes the empty-string default.
+            const merged = command.optsWithGlobals();
+            const passphrase = merged.passphrase ?? opts.passphrase;
+            const result = o.createApiKey(opts.name, walletIds, policyIds, passphrase, opts.expires);
             if (isJson())
                 return printJson(jsonOk({ id: result.id, name: result.name, token: result.token, wallets: walletIds, policies: policyIds, expires: opts.expires ?? null }));
             console.log(chalk.green.bold("\n  OWS API Key Created\n"));

package/dist/exchanges/aster-typed-data.d.ts

@@ -25,6 +25,15 @@ export declare const ASTER_DOMAIN_B: {
     readonly version: "1";
     readonly verifyingContract: "0x0000000000000000000000000000000000000000";
 };
+/** Domain B (testnet): chainId=714 per Aster V3 testnet docs. */
+export declare const ASTER_DOMAIN_B_TESTNET: {
+    readonly chainId: 714;
+    readonly name: "AsterSignTransaction";
+    readonly version: "1";
+    readonly verifyingContract: "0x0000000000000000000000000000000000000000";
+};
+/** Returns the Domain B object for the requested network (testnet branches chainId). */
+export declare function getAsterDomainB(testnet: boolean): typeof ASTER_DOMAIN_B | typeof ASTER_DOMAIN_B_TESTNET;
 /** EIP-712 types for Domain B order signing — single msg string (URL-encoded query string). */
 export declare const ORDER_TYPES: {
     readonly Message: readonly [{
@@ -113,11 +122,15 @@ export declare function buildOrderQueryStringMsg(orderParams: Record<string, str
 /**
  * Build the EIP-712 typed-data payload for agent-signed order requests.
  *
- * Domain B (chainId=1666), primaryType="Message", single `msg` field containing
- * the URL-encoded query string produced by buildOrderQueryStringMsg.
+ * Domain B (chainId=1666 mainnet / 714 testnet), primaryType="Message",
+ * single `msg` field containing the URL-encoded query string produced by
+ * buildOrderQueryStringMsg.
+ *
+ * @param testnet When true, returns Domain B with chainId=714 per Aster V3
+ *                testnet docs. Defaults to false (mainnet).
  */
-export declare function buildOrderTypedData(orderParams: Record<string, string | number | boolean>): {
-    domain: typeof ASTER_DOMAIN_B;
+export declare function buildOrderTypedData(orderParams: Record<string, string | number | boolean>, testnet?: boolean): {
+    domain: typeof ASTER_DOMAIN_B | typeof ASTER_DOMAIN_B_TESTNET;
     types: typeof ORDER_TYPES;
     primaryType: "Message";
     message: {

package/dist/exchanges/aster-typed-data.js

@@ -24,6 +24,15 @@ export const ASTER_DOMAIN_B = {
     ...ASTER_DOMAIN_A,
     chainId: 1666,
 };
+/** Domain B (testnet): chainId=714 per Aster V3 testnet docs. */
+export const ASTER_DOMAIN_B_TESTNET = {
+    ...ASTER_DOMAIN_A,
+    chainId: 714,
+};
+/** Returns the Domain B object for the requested network (testnet branches chainId). */
+export function getAsterDomainB(testnet) {
+    return testnet ? ASTER_DOMAIN_B_TESTNET : ASTER_DOMAIN_B;
+}
 /** EIP-712 types for Domain B order signing — single msg string (URL-encoded query string). */
 export const ORDER_TYPES = {
     Message: [{ name: "msg", type: "string" }],
@@ -136,13 +145,17 @@ export function buildOrderQueryStringMsg(orderParams) {
 /**
  * Build the EIP-712 typed-data payload for agent-signed order requests.
  *
- * Domain B (chainId=1666), primaryType="Message", single `msg` field containing
- * the URL-encoded query string produced by buildOrderQueryStringMsg.
+ * Domain B (chainId=1666 mainnet / 714 testnet), primaryType="Message",
+ * single `msg` field containing the URL-encoded query string produced by
+ * buildOrderQueryStringMsg.
+ *
+ * @param testnet When true, returns Domain B with chainId=714 per Aster V3
+ *                testnet docs. Defaults to false (mainnet).
  */
-export function buildOrderTypedData(orderParams) {
+export function buildOrderTypedData(orderParams, testnet = false) {
     const msg = buildOrderQueryStringMsg(orderParams);
     return {
-        domain: ASTER_DOMAIN_B,
+        domain: getAsterDomainB(testnet),
         types: ORDER_TYPES,
         primaryType: "Message",
         message: { msg },

package/dist/exchanges/aster.d.ts

@@ -1,10 +1,17 @@
 /**
- * Aster DEX adapter — EIP-712 three-tier signer routing (v3.2).
+ * Aster DEX adapter — EIP-712 agent-only signer routing (v3.3).
  *
- * Signer priority:
- *   Tier 1 — Agent OWS wallet  (registered + not expired + no --no-agent)
- *   Tier 2 — OWS master wallet (--ows / owsActiveWallet)
- *   Tier 3 — PK direct         (--private-key / PRIVATE_KEY / ASTER_PRIVATE_KEY)
+ * Signer policy:
+ *   Tier 1 — Agent OWS wallet  (registered + not expired + no --no-agent) — REQUIRED
+ *   Tier 2 — OWS master        — NOT_SUPPORTED (venue rejects master self-signing)
+ *   Tier 3 — PK direct         — NOT_SUPPORTED (venue rejects master self-signing)
+ *
+ * Aster V3 spec requires `signer` to be a registered API_WALLET (agent). The
+ * master wallet is never a valid signer — venue returns
+ * `code:-1000 msg:"Signature check failed"` when user==signer==master, even
+ * though the EIP-712 envelope is well-formed. Master/PK signers are still
+ * accepted via setMasterSigner/setPkSigner (used during approveAgent flow),
+ * but signed read/trade requests must use Tier 1.
  *
  * HMAC paths fully removed (see Step 3 plan — all Binance-compat HMAC code deleted).
  *
@@ -15,6 +22,14 @@ import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrd
 import type { EvmSigner } from "../signer/interface.js";
 import type { AgentMeta } from "../settings.js";
 import type { AgentSigningStrategy } from "../agent-wallet/signing-strategy.js";
+type ResolvedSigner = {
+    tier: "agent" | "master" | "pk";
+    signer: EvmSigner | AgentSigningStrategy;
+    /** EVM address that will appear in the `signer` field of Aster requests */
+    signerAddress: string;
+    /** EVM address of the owner/master — used as `user` field in Aster requests */
+    userAddress: string;
+};
 export declare class AsterAdapter implements ExchangeAdapter {
     readonly name = "aster";
     readonly chain = "bnb";
@@ -88,7 +103,13 @@ export declare class AsterAdapter implements ExchangeAdapter {
         assetId?: number;
         routeType?: number;
     }): Promise<unknown>;
-    private _resolveSigner;
+    /**
+     * Resolve the active signer per the three-tier policy.
+     *
+     * Exposed (leading underscore) for unit-test access only — do not call
+     * from production code outside this class.
+     */
+    _resolveSigner(): ResolvedSigner;
     private _nextNonce;
     /**
      * Build the canonical signed-request URL per Aster v3 spec.
@@ -102,24 +123,56 @@ export declare class AsterAdapter implements ExchangeAdapter {
      * signed dict and the URL query string must be byte-identical except for
      * the appended signature.
      *
+     * Both `user` and `signer` are ALWAYS emitted as distinct query fields.
+     * In production (Tier 1 only), `user` is the master and `signer` is the
+     * registered agent address. Aster's authority server checks both fields.
+     *
      * `signatureChainId` is NOT a v3 parameter — it's an artifact of an older
      * scheme; including it breaks signature verification on every call.
+     *
+     * Exposed (with leading underscore) for unit-test access only — do not call
+     * from production code outside this class.
      */
-    private _buildSignedQueryString;
+    _buildSignedQueryString(params: Record<string, string | number | boolean>, resolved: ResolvedSigner): Promise<string>;
     /**
      * Sign and POST to a path using EIP-712 Domain B.
      */
     private _signedPostEip712;
     /**
      * Sign and GET from a path using EIP-712 Domain B.
+     *
+     * Unlike public GETs, signed GETs route through _handleAsterResponse so
+     * venue JSON error envelopes ({code, msg}) are not silently treated as
+     * success (SSOT Rule #2).
+     *
+     * Retries up to 3 attempts with exponential backoff (2s/4s/8s) on HTTP 429
+     * rate-limit. Each retry rebuilds a fresh signed query string (new nonce
+     * + signature) — Aster reuses recent nonces strictly, so reusing a stale
+     * one would itself be rejected. Non-429 venue errors throw immediately.
      */
     private _signedGetEip712;
     /**
      * Sign and DELETE from a path using EIP-712 Domain B.
+     * Same retry behavior as _signedGetEip712.
      */
     private _signedDeleteEip712;
-    private _handleEip712Response;
-    /** Handle 429 rate limit with retry — used by GET/DELETE multi-attempt loops */
+    /** Shared GET/DELETE retry loop with fresh-nonce per attempt. */
+    private _signedRequestWithRetry;
+    /**
+     * Unified response validator for ALL signed Aster requests.
+     *
+     * Validates BOTH HTTP status AND the venue JSON error envelope. Aster's
+     * API commonly returns HTTP 200 + `{code, msg: "Signature check failed"}`
+     * for signing or auth failures — checking only HTTP status would silently
+     * accept these as success and cause callers (e.g., getBalance) to cache
+     * zero balances or empty arrays. SSOT Rule #2: failures throw with
+     * remediation; never substitute a default.
+     *
+     * Used by signed POST/GET/DELETE. Public unsigned GETs use _handleResponse.
+     */
+    private _handleAsterResponse;
+    /** Handle 429 rate limit with retry — used by public unsigned GET multi-attempt loops */
     private _handleResponse;
     private _publicGet;
 }
+export {};

package/dist/exchanges/aster.js

@@ -1,10 +1,17 @@
 /**
- * Aster DEX adapter — EIP-712 three-tier signer routing (v3.2).
+ * Aster DEX adapter — EIP-712 agent-only signer routing (v3.3).
  *
- * Signer priority:
- *   Tier 1 — Agent OWS wallet  (registered + not expired + no --no-agent)
- *   Tier 2 — OWS master wallet (--ows / owsActiveWallet)
- *   Tier 3 — PK direct         (--private-key / PRIVATE_KEY / ASTER_PRIVATE_KEY)
+ * Signer policy:
+ *   Tier 1 — Agent OWS wallet  (registered + not expired + no --no-agent) — REQUIRED
+ *   Tier 2 — OWS master        — NOT_SUPPORTED (venue rejects master self-signing)
+ *   Tier 3 — PK direct         — NOT_SUPPORTED (venue rejects master self-signing)
+ *
+ * Aster V3 spec requires `signer` to be a registered API_WALLET (agent). The
+ * master wallet is never a valid signer — venue returns
+ * `code:-1000 msg:"Signature check failed"` when user==signer==master, even
+ * though the EIP-712 envelope is well-formed. Master/PK signers are still
+ * accepted via setMasterSigner/setPkSigner (used during approveAgent flow),
+ * but signed read/trade requests must use Tier 1.
  *
  * HMAC paths fully removed (see Step 3 plan — all Binance-compat HMAC code deleted).
  *
@@ -501,6 +508,12 @@ export class AsterAdapter {
         throw new Error("Aster withdrawal requires the spot API (not available in futures mode). Use the Aster web UI to withdraw.");
     }
     // ── Private: signer resolution ────────────────────────────────────────────
+    /**
+     * Resolve the active signer per the three-tier policy.
+     *
+     * Exposed (leading underscore) for unit-test access only — do not call
+     * from production code outside this class.
+     */
     _resolveSigner() {
         // Tier 1: agent (when registered, not expired, --no-agent NOT set)
         if (!this._useNoAgent && this._agentSigner && this._agentMeta) {
@@ -522,15 +535,19 @@ export class AsterAdapter {
                 };
             }
         }
-        // Tier 2: OWS master
-        if (this._masterSigner) {
-            const addr = this._masterSigner.getAddress();
-            return { tier: "master", signer: this._masterSigner, signerAddress: addr, userAddress: addr };
-        }
-        // Tier 3: PK direct
-        if (this._pkSigner) {
-            const addr = this._pkSigner.getAddress();
-            return { tier: "pk", signer: this._pkSigner, signerAddress: addr, userAddress: addr };
+        // Tier 2/3: master self-signing is not supported by the venue. Per Aster
+        // V3 spec the `signer` field MUST be a registered API_WALLET (agent);
+        // sending `user==signer==master` is rejected with
+        // `code:-1000 msg:"Signature check failed"` even though the EIP-712
+        // envelope is well-formed. SSOT Rule #2: throw with remediation rather
+        // than silently dispatching a request the venue will reject.
+        //
+        // Reference: HypurrQuant_FE AsterPerpAdapter.ts throws if agent isn't
+        // configured; never attempts master self-signing.
+        if (this._masterSigner || this._pkSigner) {
+            throw new PerpError("NOT_IMPLEMENTED", "Aster requires a registered agent — master self-signing is not supported by venue", {
+                remediation: "perp wallet agent approve aster --master <wallet>",
+            });
         }
         // No signer at any tier
         throw new PerpError("NO_SIGNER_AVAILABLE", "No signing path configured for Aster", {
@@ -555,8 +572,15 @@ export class AsterAdapter {
      * signed dict and the URL query string must be byte-identical except for
      * the appended signature.
      *
+     * Both `user` and `signer` are ALWAYS emitted as distinct query fields.
+     * In production (Tier 1 only), `user` is the master and `signer` is the
+     * registered agent address. Aster's authority server checks both fields.
+     *
      * `signatureChainId` is NOT a v3 parameter — it's an artifact of an older
      * scheme; including it breaks signature verification on every call.
+     *
+     * Exposed (with leading underscore) for unit-test access only — do not call
+     * from production code outside this class.
      */
     async _buildSignedQueryString(params, resolved) {
         // Insertion order (matches Python reference: nonce, user, signer last).
@@ -566,7 +590,7 @@ export class AsterAdapter {
             user: resolved.userAddress,
             signer: resolved.signerAddress,
         };
-        const typed = buildOrderTypedData(fullParams);
+        const typed = buildOrderTypedData(fullParams, this._testnet);
         // Sign via the appropriate signer type
         const sigRaw = await resolved.signer.signTypedData(typed.domain, typed.types, typed.message);
         // Normalize: AgentSigningStrategy returns { signature, r, s, v }; EvmSigner returns string
@@ -586,38 +610,76 @@ export class AsterAdapter {
             headers: { "Content-Type": "application/x-www-form-urlencoded" },
             body: "",
         });
-        return this._handleEip712Response(res, "POST", path);
+        return this._handleAsterResponse(res, "POST", path);
     }
     /**
      * Sign and GET from a path using EIP-712 Domain B.
+     *
+     * Unlike public GETs, signed GETs route through _handleAsterResponse so
+     * venue JSON error envelopes ({code, msg}) are not silently treated as
+     * success (SSOT Rule #2).
+     *
+     * Retries up to 3 attempts with exponential backoff (2s/4s/8s) on HTTP 429
+     * rate-limit. Each retry rebuilds a fresh signed query string (new nonce
+     * + signature) — Aster reuses recent nonces strictly, so reusing a stale
+     * one would itself be rejected. Non-429 venue errors throw immediately.
      */
     async _signedGetEip712(path, params, resolved) {
-        const qs = await this._buildSignedQueryString(params, resolved);
-        const url = `${this._baseUrl}${path}?${qs}`;
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const res = await fetch(url);
-            const result = await this._handleResponse(res, "GET", path, attempt);
-            if (result !== null)
-                return result;
-        }
-        throw new Error(`GET ${path} failed: max retries exceeded`);
+        return this._signedRequestWithRetry("GET", path, params, resolved);
     }
     /**
      * Sign and DELETE from a path using EIP-712 Domain B.
+     * Same retry behavior as _signedGetEip712.
      */
     async _signedDeleteEip712(path, params, resolved) {
-        const qs = await this._buildSignedQueryString(params, resolved);
-        const url = `${this._baseUrl}${path}?${qs}`;
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const res = await fetch(url, { method: "DELETE" });
-            const result = await this._handleResponse(res, "DELETE", path, attempt);
-            if (result !== null)
-                return result;
+        return this._signedRequestWithRetry("DELETE", path, params, resolved);
+    }
+    /** Shared GET/DELETE retry loop with fresh-nonce per attempt. */
+    async _signedRequestWithRetry(method, path, params, resolved) {
+        const MAX_ATTEMPTS = 3;
+        let lastErr;
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            // Rebuild signed query string with fresh nonce on each attempt.
+            const qs = await this._buildSignedQueryString(params, resolved);
+            const url = `${this._baseUrl}${path}?${qs}`;
+            const res = await fetch(url, method === "DELETE" ? { method: "DELETE" } : undefined);
+            // 429 → backoff + retry. All other paths (including non-429 venue
+            // errors wrapped in HTTP 200 with code≠0) throw immediately via
+            // _handleAsterResponse — no silent fallback (Rule #2).
+            if (res.status === 429 && attempt < MAX_ATTEMPTS - 1) {
+                const backoffMs = 2000 * Math.pow(2, attempt); // 2s, 4s, 8s
+                await new Promise((r) => setTimeout(r, backoffMs));
+                continue;
+            }
+            try {
+                return await this._handleAsterResponse(res, method, path);
+            }
+            catch (e) {
+                lastErr = e;
+                if (res.status === 429 && attempt < MAX_ATTEMPTS - 1) {
+                    const backoffMs = 2000 * Math.pow(2, attempt);
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    continue;
+                }
+                throw e;
+            }
         }
-        throw new Error(`DELETE ${path} failed: max retries exceeded`);
+        throw lastErr;
     }
     // ── Private: HTTP response handling ──────────────────────────────────────
-    async _handleEip712Response(res, method, path) {
+    /**
+     * Unified response validator for ALL signed Aster requests.
+     *
+     * Validates BOTH HTTP status AND the venue JSON error envelope. Aster's
+     * API commonly returns HTTP 200 + `{code, msg: "Signature check failed"}`
+     * for signing or auth failures — checking only HTTP status would silently
+     * accept these as success and cause callers (e.g., getBalance) to cache
+     * zero balances or empty arrays. SSOT Rule #2: failures throw with
+     * remediation; never substitute a default.
+     *
+     * Used by signed POST/GET/DELETE. Public unsigned GETs use _handleResponse.
+     */
+    async _handleAsterResponse(res, method, path) {
         if (res.status === 429) {
             const retryAfter = parseInt(res.headers.get("Retry-After") || "5", 10);
             await new Promise(r => setTimeout(r, Math.min(retryAfter * 1000, 30000)));
@@ -628,15 +690,28 @@ export class AsterAdapter {
             const s = classifyError(new Error(`${method} ${path} failed (${res.status}): ${text.slice(0, 200)}`), "aster");
             throw new PerpError(s.code, s.message, { exchange: s.exchange });
         }
-        const json = await res.json();
-        if (json.code !== undefined && json.code !== "000000" && json.code !== 200) {
-            const rawMsg = typeof json.msg === "string" ? json.msg : JSON.stringify(json);
-            const s = classifyError(new Error(rawMsg), "aster");
-            throw new PerpError(s.code, s.message, { exchange: s.exchange });
+        // Parse JSON, then validate venue error envelope. Aster success returns
+        // either an object whose `code` is "000000"/200 (or absent) or an array
+        // (e.g., GET /fapi/v3/openOrders, GET /fapi/v3/userTrades).
+        const text = await res.text();
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new PerpError("EXCHANGE_ERROR", `${method} ${path}: malformed JSON: ${text.slice(0, 200)}`, { exchange: "aster" });
+        }
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const json = parsed;
+            if (json.code !== undefined && json.code !== "000000" && json.code !== 200 && json.code !== 0) {
+                const rawMsg = typeof json.msg === "string" ? json.msg : JSON.stringify(json);
+                const s = classifyError(new Error(rawMsg), "aster");
+                throw new PerpError(s.code, s.message, { exchange: s.exchange });
+            }
         }
-        return json;
+        return parsed;
     }
-    /** Handle 429 rate limit with retry — used by GET/DELETE multi-attempt loops */
+    /** Handle 429 rate limit with retry — used by public unsigned GET multi-attempt loops */
     async _handleResponse(res, method, path, attempt = 0) {
         if (res.status === 429) {
             if (attempt >= 2)

package/dist/exchanges/hyperliquid.js

@@ -392,6 +392,12 @@ export class HyperliquidAdapter {
             // via `wallet manage account-mode unified`.
             if (raw === "default")
                 return "standard";
+            // "dexAbstraction" is HL's legacy fourth mode, slated for deprecation
+            // but still returned by the venue for some users. Per HL docs the spot
+            // pool acts as collateral (same accounting semantics as unified), so
+            // route through the unified branch rather than throwing.
+            if (raw === "dexAbstraction")
+                return "unified";
             throw new PerpError("INVALID_PARAMS", `UNKNOWN_ACCOUNT_MODE: HL returned unrecognized userAbstraction mode: ${JSON.stringify(raw)}`, { remediation: "Check app.hyperliquid.xyz Settings → Account Mode" });
         });
     }
@@ -424,6 +430,12 @@ export class HyperliquidAdapter {
         // - "standard": separate perp/spot accounting; perp clearinghouse is the
         //   only collateral source. Required mode for builder fee accrual.
         // HIP-3 dex accounts (this._dex) always use standard semantics.
+        //
+        // Portfolio-margin mode: per HL portfolio-margin docs, eligible collateral
+        // includes HYPE, BTC, USDH, USDC. We currently use USDC-only as a minimum
+        // viable baseline (mark-priced multi-asset accounting requires fetching
+        // spot mark prices and is deferred to a follow-up). Emit a stderr note so
+        // users see the breakdown when non-USDC collateral is present.
         const mode = await this._getAbstractionMode();
         if (mode === "unified" || mode === "portfolio") {
             const spotState = await this._getSpotClearinghouseState();
@@ -433,6 +445,22 @@ export class HyperliquidAdapter {
             const spotHold = Number(usdc?.hold ?? 0);
             equity = spotTotal;
             available = spotTotal - spotHold;
+            if (mode === "portfolio") {
+                const PORTFOLIO_COLLATERAL = ["HYPE", "BTC", "USDH"];
+                const nonUsdc = balances.filter((b) => {
+                    const coin = String(b.coin);
+                    if (coin.startsWith("USDC"))
+                        return false;
+                    if (Number(b.total ?? 0) <= 0)
+                        return false;
+                    return PORTFOLIO_COLLATERAL.some((c) => coin === c || coin.startsWith(`${c}-`));
+                });
+                if (nonUsdc.length > 0) {
+                    const summary = nonUsdc.map((b) => `${b.coin}=${b.total}`).join(", ");
+                    process.stderr.write(`[hl] portfolio mode: non-USDC collateral present but not counted in equity (${summary}). ` +
+                        `Equity reflects USDC only; full multi-asset accounting pending.\n`);
+                }
+            }
         }
         else {
             // mode === "standard"

package/dist/index.js

@@ -587,7 +587,7 @@ if (rawArgs.length === 0 || (!hasSubcommand && !rawArgs.includes("-h") && !rawAr
             const settings = loadSettings();
             const hasEnvKey = !!(process.env.PRIVATE_KEY || process.env.PACIFICA_PRIVATE_KEY ||
                 process.env.HL_PRIVATE_KEY || process.env.HYPERLIQUID_PRIVATE_KEY ||
-                process.env.LIGHTER_PRIVATE_KEY);
+                process.env.LIGHTER_PRIVATE_KEY || process.env.ASTER_PRIVATE_KEY);
             const hasOwsWallet = !!settings.owsActiveWallet;
             // ── ASCII banner ──
             const banner = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.12.10",
+  "version": "0.12.12",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster",
   "bin": {
     "perp": "dist/index.js",

package/skills/perp-cli/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: "Bash(perp:*), Bash(npx perp-cli:*), Bash(npx -y perp-cli:*)"
 license: MIT
 metadata:
   author: hypurrquant
-  version: "0.12.10"
+  version: "0.12.12"
 ---
 
 # perp-cli Agent Guide
@@ -41,7 +41,7 @@ Multi-DEX perpetual futures CLI + MCP server — Pacifica (Solana), Hyperliquid
 ## Install
 
 ```bash
-perp --version 2>/dev/null  # check if exists (must be >= 0.12.10)
+perp --version 2>/dev/null  # check if exists (must be >= 0.12.12)
 npm install -g perp-cli@latest 2>/dev/null || npx -y perp-cli@latest --json --version
 ```