perp-cli 0.15.0 → 0.16.0

package/dist/exchanges/venue.d.ts

@@ -9,8 +9,9 @@
  * `create`) so that public-data paths never pull in heavy SDKs (lighter WASM).
  */
 import { PerpError } from "../errors.js";
-import type { ExchangeAdapter } from "./interface.js";
-import type { SpotAdapter } from "./spot-interface.js";
+import type { ExchangeAdapter, ExchangeBalance, ExchangePosition } from "./interface.js";
+import { type AddressKind } from "./address.js";
+import type { SpotAdapter, SpotBalance } from "./spot-interface.js";
 import type { FundingRateBasis, LegacyVenueId, Network, TimeInForce, VenueFundingRate, VenueId, VenueMarket } from "./venue-types.js";
 import { isVenueId } from "./venue-types.js";
 import type { AnyAgentMeta } from "../settings.js";
@@ -104,7 +105,75 @@ export interface RateLimitPolicy {
 }
 export interface VenuePublicData {
     fetchFundingRates(net: Network): Promise<VenueFundingRate[]>;
-    fetchMarkets(net: Network): Promise<VenueMarket[]>;
+    /**
+     * `opts.funding: false` = the caller needs marks / precision only: a venue whose funding rate
+     * costs an extra read (Lighter: the WS market_stats snapshot) skips it (rows fundingRate null).
+     */
+    fetchMarkets(net: Network, opts?: {
+        funding?: boolean;
+    }): Promise<VenueMarket[]>;
+    /**
+     * Keyless open positions of ANY account by its public address (`account positions --address`,
+     * MCP get_positions_by_address). Present = the venue supports it; `addressKind` is then the
+     * address format it takes (checked before any request). Rows are the keyed `getPositions`
+     * mapping (the same mapper) with plain symbols.
+     */
+    addressKind?: AddressKind;
+    fetchPositionsByAddress?(net: Network, address: string, opts: PublicPositionsOptions): Promise<PublicPositionsResult>;
+    /**
+     * Keyless balances of ANY account by its public address (`account balance --address`, MCP
+     * get_balance_by_address). Present = the venue supports it (takes `addressKind`, like
+     * fetchPositionsByAddress). The balance is the keyed `getBalance` math (the same function).
+     */
+    fetchBalanceByAddress?(net: Network, address: string, opts: PublicPositionsOptions): Promise<PublicBalanceResult>;
+}
+/** One Lighter account (sub-account) of an address: its balance and spot assets. */
+export interface PublicAccountBalance {
+    accountIndex: number;
+    balance: ExchangeBalance;
+    spot: SpotBalance[];
+}
+export interface PublicBalanceResult {
+    /** The account's balance (the keyed getBalance fields + the venue's extras); null on Lighter (per account in `accounts`). */
+    balance: ExchangeBalance | null;
+    /** Spot token balances where the venue publishes them by address; null = not published (nothing invented). */
+    spot: SpotBalance[] | null;
+    /** Lighter / Lighter RH: every account of the address (or the one of accountIndex); null elsewhere. */
+    accounts: PublicAccountBalance[] | null;
+    /** Hyperliquid: HIP-3 dexes with a non-zero account value (the dex's own perp clearinghouse); null elsewhere. */
+    dexes: Record<string, ExchangeBalance> | null;
+    /** Hyperliquid: the account abstraction mode the balance was read under; null elsewhere. */
+    accountMode: string | null;
+    /** Sub-reads that failed (Hyperliquid: one HIP-3 dex, "hip3:<dex>") — unknown, never zero. */
+    errors: Record<string, {
+        code: string;
+        message: string;
+    }>;
+    notes: string[];
+}
+export interface PublicPositionsOptions {
+    /** Lighter: one account of the address (sub-accounts); default every account. */
+    accountIndex?: number;
+}
+/** A position read by public address: the keyed row plus where it lives. */
+export interface PublicPosition extends ExchangePosition {
+    /** Hyperliquid: the HIP-3 dex of the row; null = the native perp dex. */
+    dex?: string | null;
+    /** Lighter: the account (sub-account) index the row belongs to. */
+    accountIndex?: number;
+}
+export interface PublicPositionsResult {
+    positions: PublicPosition[];
+    /**
+     * Sub-reads that failed while the others succeeded (Hyperliquid: one HIP-3 dex), keyed by
+     * source ("hip3:xyz"). Their rows are unknown — never silently absent: callers surface them.
+     */
+    errors: Record<string, {
+        code: string;
+        message: string;
+    }>;
+    /** Human notes on an empty answer ("no Lighter account for this address"). */
+    notes: string[];
 }
 export interface VenueCredentials {
     /** Raw private key from --private-key or (legacy venues only) env. */
@@ -216,6 +285,24 @@ export declare function tryResolveVenueId(nameOrAlias: string): VenueId | null;
 export declare function getVenue(nameOrAlias: string): VenueDefinition;
 export declare function listVenues(): VenueDefinition[];
 export declare function listVenuesWithRole(role: VenueRole): VenueDefinition[];
+/** Venues that read positions by public address (VenuePublicData.fetchPositionsByAddress). */
+export declare function listPublicPositionVenues(): VenueDefinition[];
+/** CAPABILITY_UNSUPPORTED for a venue without public-address position reads (registry-derived). */
+export declare function publicPositionsUnsupported(def: VenueDefinition): PerpError;
+/**
+ * Open positions of `address` on `venue`, keyless: unsupported venue → CAPABILITY_UNSUPPORTED,
+ * wrong address format → INVALID_PARAMS, both before any request.
+ */
+export declare function fetchPositionsByAddress(venue: string, net: Network, address: string, opts?: PublicPositionsOptions): Promise<PublicPositionsResult>;
+/** Venues that read balances by public address (VenuePublicData.fetchBalanceByAddress). */
+export declare function listPublicBalanceVenues(): VenueDefinition[];
+/** CAPABILITY_UNSUPPORTED for a venue without public-address balance reads (registry-derived). */
+export declare function publicBalanceUnsupported(def: VenueDefinition): PerpError;
+/**
+ * Balances of `address` on `venue`, keyless: unsupported venue → CAPABILITY_UNSUPPORTED, wrong
+ * address format → INVALID_PARAMS, both before any request.
+ */
+export declare function fetchBalanceByAddress(venue: string, net: Network, address: string, opts?: PublicPositionsOptions): Promise<PublicBalanceResult>;
 export declare function networkConfig(def: VenueDefinition, net: Network): VenueNetworkConfig;
 /**
  * The uniform refusal for any account / trading / funds / agent / builder / bot action on a venue
@@ -248,6 +335,15 @@ export declare function settlementIntervalOf(ref: string): number;
  * CAPABILITY_UNSUPPORTED. Unknown venue refs throw UNKNOWN_VENUE.
  */
 export declare function assertFundingArbVenue(ref: string): void;
+/**
+ * Market rows (`market list|prices|info`, MCP get_markets) state whether their venue's funding rate
+ * is verified — on every venue, true or false (VenueDefinition.fundingVerified), so a consumer
+ * never has to read a missing field as "verified". A venue ref ("hip3:xyz" → hyperliquid) is
+ * resolved; an unknown ref leaves the rows as they are.
+ */
+export declare function withFundingVerified<T extends object>(venue: string, rows: T[]): Array<T & {
+    fundingVerified: boolean;
+}> | T[];
 export declare function isLegacyVenue(def: VenueDefinition): def is VenueDefinition & {
     id: LegacyVenueId;
 };

package/dist/exchanges/venue.js

@@ -9,6 +9,7 @@
  * `create`) so that public-data paths never pull in heavy SDKs (lighter WASM).
  */
 import { PerpError } from "../errors.js";
+import { requireAddressOfKind } from "./address.js";
 import { isVenueId } from "./venue-types.js";
 import { optionsVenueWords } from "./options-venues.js";
 export const READ_ONLY_CREDENTIALS = {
@@ -72,6 +73,64 @@ export function listVenues() {
 export function listVenuesWithRole(role) {
     return listVenues().filter(v => v.roles.includes(role));
 }
+/** Venues that read positions by public address (VenuePublicData.fetchPositionsByAddress). */
+export function listPublicPositionVenues() {
+    return listVenues().filter(v => typeof v.publicData.fetchPositionsByAddress === "function" && v.publicData.addressKind !== undefined);
+}
+/** CAPABILITY_UNSUPPORTED for a venue without public-address position reads (registry-derived). */
+export function publicPositionsUnsupported(def) {
+    const reason = !def.roles.includes("account")
+        ? `${def.displayName} is available for market data only (no account reads)`
+        : `${def.displayName} publishes positions only to the account itself (signed or API-key reads)`;
+    const supported = listPublicPositionVenues().map(v => v.id).join(", ");
+    return new PerpError("CAPABILITY_UNSUPPORTED", `${def.id} does not support publicPositions — ${reason}`, {
+        venue: def.id, feature: "publicPositions", reason,
+        remediation: `Public-address reads: ${supported}; for your own account: perp -e ${def.id} account positions`,
+    });
+}
+/**
+ * Open positions of `address` on `venue`, keyless: unsupported venue → CAPABILITY_UNSUPPORTED,
+ * wrong address format → INVALID_PARAMS, both before any request.
+ */
+export async function fetchPositionsByAddress(venue, net, address, opts = {}) {
+    const def = getVenue(venue);
+    const pd = def.publicData;
+    if (pd.fetchPositionsByAddress === undefined || pd.addressKind === undefined)
+        throw publicPositionsUnsupported(def);
+    if (opts.accountIndex !== undefined && def.id !== "lighter" && def.id !== "lighter-rh") {
+        throw new PerpError("INVALID_PARAMS", `--account-index applies to Lighter only (${def.id} has one account per address)`, { exchange: def.id, remediation: "Drop --account-index" });
+    }
+    return pd.fetchPositionsByAddress(net, requireAddressOfKind(def.id, pd.addressKind, address), opts);
+}
+/** Venues that read balances by public address (VenuePublicData.fetchBalanceByAddress). */
+export function listPublicBalanceVenues() {
+    return listVenues().filter(v => typeof v.publicData.fetchBalanceByAddress === "function" && v.publicData.addressKind !== undefined);
+}
+/** CAPABILITY_UNSUPPORTED for a venue without public-address balance reads (registry-derived). */
+export function publicBalanceUnsupported(def) {
+    const reason = !def.roles.includes("account")
+        ? `${def.displayName} is available for market data only (no account reads)`
+        : `${def.displayName} publishes balances only to the account itself (signed or API-key reads)`;
+    const supported = listPublicBalanceVenues().map(v => v.id).join(", ");
+    return new PerpError("CAPABILITY_UNSUPPORTED", `${def.id} does not support publicBalance — ${reason}`, {
+        venue: def.id, feature: "publicBalance", reason,
+        remediation: `Public-address reads: ${supported}; for your own account: perp -e ${def.id} portfolio`,
+    });
+}
+/**
+ * Balances of `address` on `venue`, keyless: unsupported venue → CAPABILITY_UNSUPPORTED, wrong
+ * address format → INVALID_PARAMS, both before any request.
+ */
+export async function fetchBalanceByAddress(venue, net, address, opts = {}) {
+    const def = getVenue(venue);
+    const pd = def.publicData;
+    if (pd.fetchBalanceByAddress === undefined || pd.addressKind === undefined)
+        throw publicBalanceUnsupported(def);
+    if (opts.accountIndex !== undefined && def.id !== "lighter" && def.id !== "lighter-rh") {
+        throw new PerpError("INVALID_PARAMS", `--account-index applies to Lighter only (${def.id} has one account per address)`, { exchange: def.id, remediation: "Drop --account-index" });
+    }
+    return pd.fetchBalanceByAddress(net, requireAddressOfKind(def.id, pd.addressKind, address), opts);
+}
 export function networkConfig(def, net) {
     const cfg = def.networks[net];
     if (!cfg) {
@@ -176,6 +235,19 @@ export function assertFundingArbVenue(ref) {
         remediation: `Use venues with verified funding (${listVenues().filter(v => v.fundingVerified && v.roles.includes("trading")).map(v => v.id).join(", ")}). ${def.displayName} rates can still be viewed: perp arb scan --rates --include-unverified`,
     });
 }
+/**
+ * Market rows (`market list|prices|info`, MCP get_markets) state whether their venue's funding rate
+ * is verified — on every venue, true or false (VenueDefinition.fundingVerified), so a consumer
+ * never has to read a missing field as "verified". A venue ref ("hip3:xyz" → hyperliquid) is
+ * resolved; an unknown ref leaves the rows as they are.
+ */
+export function withFundingVerified(venue, rows) {
+    const id = tryResolveVenueId(venue.startsWith("hip3:") ? "hyperliquid" : venue);
+    const def = id === null ? undefined : _venues.get(id);
+    if (def === undefined)
+        return rows;
+    return rows.map(r => ({ ...r, fundingVerified: def.fundingVerified }));
+}
 export function isLegacyVenue(def) {
     return def.id === "pacifica" || def.id === "hyperliquid" || def.id === "lighter" || def.id === "aster";
 }

package/dist/exchanges/venues/hyperliquid.js

@@ -26,6 +26,15 @@ const publicData = {
     async fetchMarkets(net) {
         return (await import("../../funding/legacy-public.js")).legacyPublicData("hyperliquid").fetchMarkets(net);
     },
+    // Keyless positions of any account by public address (account positions --address).
+    addressKind: "evm",
+    async fetchPositionsByAddress(net, address) {
+        return (await import("../public-positions.js")).hyperliquidPositionsByAddress(net, address);
+    },
+    // Keyless balances of any account by public address (account balance --address).
+    async fetchBalanceByAddress(net, address) {
+        return (await import("../public-balances.js")).hyperliquidBalanceByAddress(net, address);
+    },
 };
 export const hyperliquidVenue = {
     id: "hyperliquid",

package/dist/exchanges/venues/lighter-rh.js

@@ -9,8 +9,17 @@ const publicData = {
     async fetchFundingRates(net) {
         return (await import("../lighter-public.js")).lighterPublicData("lighter-rh").fetchFundingRates(net);
     },
-    async fetchMarkets(net) {
-        return (await import("../lighter-public.js")).lighterPublicData("lighter-rh").fetchMarkets(net);
+    async fetchMarkets(net, opts) {
+        return (await import("../lighter-public.js")).lighterPublicData("lighter-rh").fetchMarkets(net, opts);
+    },
+    // Keyless positions of any account by public address (account positions --address).
+    addressKind: "evm",
+    async fetchPositionsByAddress(net, address, opts) {
+        return (await import("../public-positions.js")).lighterPositionsByAddress("lighter-rh", net, address, opts);
+    },
+    // Keyless balances of any account by public address (account balance --address).
+    async fetchBalanceByAddress(net, address, opts) {
+        return (await import("../public-balances.js")).lighterBalanceByAddress("lighter-rh", net, address, opts);
     },
 };
 export const lighterRhVenue = {
@@ -23,7 +32,8 @@ export const lighterRhVenue = {
     secretStorage: { kind: "perp-keystore", dir: "lighter-rh-agents" },
     networks: LIGHTER_RH_NETWORKS,
     // "Lighter RH is the same API/engine as Lighter" → Lighter's basis/interval (live-data check pending).
-    fundingRateBasis: { kind: "perHours", hours: 8 },
+    // The market rows' fundingRate is the settled hourly rate (WS market_stats, lighter-public.ts).
+    fundingRateBasis: { kind: "perHours", hours: 1 },
     settlementIntervalHours: 1,
     fundingVerified: true,
     roles: ["marketData", "account", "trading"],

package/dist/exchanges/venues/lighter.js

@@ -8,8 +8,17 @@ const publicData = {
     async fetchFundingRates(net) {
         return (await import("../lighter-public.js")).lighterPublicData("lighter").fetchFundingRates(net);
     },
-    async fetchMarkets(net) {
-        return (await import("../lighter-public.js")).lighterPublicData("lighter").fetchMarkets(net);
+    async fetchMarkets(net, opts) {
+        return (await import("../lighter-public.js")).lighterPublicData("lighter").fetchMarkets(net, opts);
+    },
+    // Keyless positions of any account by public address (account positions --address).
+    addressKind: "evm",
+    async fetchPositionsByAddress(net, address, opts) {
+        return (await import("../public-positions.js")).lighterPositionsByAddress("lighter", net, address, opts);
+    },
+    // Keyless balances of any account by public address (account balance --address).
+    async fetchBalanceByAddress(net, address, opts) {
+        return (await import("../public-balances.js")).lighterBalanceByAddress("lighter", net, address, opts);
     },
 };
 export const lighterVenue = {
@@ -21,7 +30,8 @@ export const lighterVenue = {
     agentKeyKind: "lighter-l2",
     secretStorage: { kind: "perp-keystore", dir: "lighter-agents" },
     networks: LIGHTER_NETWORKS,
-    fundingRateBasis: { kind: "perHours", hours: 8 },
+    // The market rows' fundingRate is the settled hourly rate (WS market_stats, lighter-public.ts).
+    fundingRateBasis: { kind: "perHours", hours: 1 },
     settlementIntervalHours: 1,
     fundingVerified: true,
     roles: ["marketData", "account", "trading"],

package/dist/exchanges/venues/pacifica.js

@@ -10,6 +10,15 @@ const publicData = {
     async fetchMarkets(net) {
         return (await import("../../funding/legacy-public.js")).legacyPublicData("pacifica").fetchMarkets(net);
     },
+    // Keyless positions of any account by public address (account positions --address).
+    addressKind: "solana",
+    async fetchPositionsByAddress(net, address) {
+        return (await import("../public-positions.js")).pacificaPositionsByAddress(net, address);
+    },
+    // Keyless balances of any account by public address (account balance --address).
+    async fetchBalanceByAddress(net, address) {
+        return (await import("../public-balances.js")).pacificaBalanceByAddress(net, address);
+    },
 };
 /** Pacifica `client_order_id` format: "Full UUID string" (docs.pacifica.fi rest-api orders/create-limit-order). */
 export const PACIFICA_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

package/dist/exchanges/venues/risex.js

@@ -35,6 +35,21 @@ const publicData = {
     async fetchMarkets(net) {
         return (await import("../risex/public.js")).risexPublicData.fetchMarkets(net);
     },
+    // Keyless positions of any account by public address (account positions --address): the
+    // adapter's own public-by-address read (/v1/portfolio/details), no signer.
+    addressKind: "evm",
+    async fetchPositionsByAddress(net, address) {
+        const { RisexAdapter } = await import("../risex/adapter.js");
+        const adapter = new RisexAdapter(risexVenue, net, { account: address, signer: null, meta: null, noSignerReason: null });
+        return { positions: await adapter.getPositions(), errors: {}, notes: [] };
+    },
+    // Keyless balance (account balance --address): the same signer-less adapter's getBalance. RISEx
+    // has no spot market: spot null.
+    async fetchBalanceByAddress(net, address) {
+        const { RisexAdapter } = await import("../risex/adapter.js");
+        const adapter = new RisexAdapter(risexVenue, net, { account: address, signer: null, meta: null, noSignerReason: null });
+        return { balance: await adapter.getBalance(), spot: null, accounts: null, dexes: null, accountMode: null, errors: {}, notes: [] };
+    },
 };
 export const risexVenue = {
     id: "risex",

package/dist/funding/legacy-public.d.ts

@@ -19,13 +19,15 @@
  *   pacifica: crypto-centric; PACIFICA_NON_CRYPTO lists every non-crypto perp
  *     listed on 2026-09-30.
  *   aster: exchangeInfo `underlyingSubType` (STOCK / ETF / Commodities / pre-launch).
- *   AMBIGUOUS tickers are excluded with a warning so they cannot produce a false
- *   cross-venue match (SPX = the SPX6900 token, whose ticker equals the S&P 500
- *   canonical key).
+ *   Ambiguous tickers (UNCLASSIFIED_TICKERS, src/ws/unclassified.ts — SPX = the SPX6900
+ *   token, whose ticker equals the S&P 500 canonical key) are listed as "unclassified"
+ *   (canonical null) so they cannot produce a false cross-venue match.
  *
  * Fields a venue does not publish on this path are null (HL has no fixed tick
  * size; Aster leverage brackets need a signed call; Aster OI is per-symbol only).
  */
 import type { VenuePublicData } from "../exchanges/venue.js";
 export type LegacyPublicVenue = "pacifica" | "hyperliquid" | "aster";
+/** One public JSON read with the venue error mapping (rate limits, HTTP status, invalid JSON). */
+export declare function legacyPublicJson(venue: LegacyPublicVenue, url: string, label: string, init?: RequestInit): Promise<unknown>;
 export declare function legacyPublicData(venue: LegacyPublicVenue): VenuePublicData;

package/dist/funding/legacy-public.js

@@ -19,24 +19,26 @@
  *   pacifica: crypto-centric; PACIFICA_NON_CRYPTO lists every non-crypto perp
  *     listed on 2026-09-30.
  *   aster: exchangeInfo `underlyingSubType` (STOCK / ETF / Commodities / pre-launch).
- *   AMBIGUOUS tickers are excluded with a warning so they cannot produce a false
- *   cross-venue match (SPX = the SPX6900 token, whose ticker equals the S&P 500
- *   canonical key).
+ *   Ambiguous tickers (UNCLASSIFIED_TICKERS, src/ws/unclassified.ts — SPX = the SPX6900
+ *   token, whose ticker equals the S&P 500 canonical key) are listed as "unclassified"
+ *   (canonical null) so they cannot produce a false cross-venue match.
  *
  * Fields a venue does not publish on this path are null (HL has no fixed tick
  * size; Aster leverage brackets need a signed call; Aster OI is per-symbol only).
  */
 import { HL_MIN_ORDER_VALUE_USD } from "../constants.js";
 import { isPacificaPerpetual } from "../ws/pacifica-instrument.js";
+import { asterCliSymbol, asterMatchable, isAsterListedPerpetual } from "../ws/aster-market.js";
+import { isUnclassifiedTicker } from "../ws/unclassified.js";
 import { PerpError } from "../errors.js";
 import { venueRateString } from "../utils/numeric.js";
 import { assertOk } from "../api/public/_http.js";
 import { legacyPublicBaseUrl } from "../api/public/urls.js";
 import { canonicalFor } from "../exchanges/canonical-symbols.js";
 import { fundingBasisOf, settlementIntervalOf } from "../exchanges/venue.js";
+import { nextTopOfHourMs } from "../exchanges/venue-types.js";
 // ── Classification ──
-const AMBIGUOUS = new Set(["SPX"]);
-/** Pacifica non-crypto perps (live /info 2026-09-30). BP / CHIP: ticker collides with a listed equity/ETF. */
+/** Pacifica non-crypto perps (live /info 2026-09-30). Ambiguous BP / CHIP / SPX: UNCLASSIFIED_TICKERS. */
 const PACIFICA_NON_CRYPTO = {
     NVDA: "equity", TSLA: "equity", GOOGL: "equity", PLTR: "equity", HOOD: "equity", CRCL: "equity",
     SPCX: "equity", SKHYNIX: "equity", SAMSUNG: "equity", MSTR: "equity", MU: "equity", SNDK: "equity",
@@ -47,19 +49,20 @@ const PACIFICA_NON_CRYPTO = {
     USDJPY: "fx", EURUSD: "fx",
     SP500: "index",
 };
-const PACIFICA_AMBIGUOUS = new Set(["BP", "CHIP"]);
+// Ambiguous tickers are listed as "unclassified" (canonical null: never matched across venues),
+// so every listing path (CLI, MCP, public directory) shows the same market set.
 function classifyPacifica(symbol) {
     const up = symbol.toUpperCase();
-    if (AMBIGUOUS.has(up) || PACIFICA_AMBIGUOUS.has(up))
-        return null;
+    if (isUnclassifiedTicker("pacifica", up))
+        return "unclassified";
     return PACIFICA_NON_CRYPTO[up] ?? "crypto"; // crypto-centric venue: non-crypto is listed explicitly
 }
 function classifyHyperliquid(symbol) {
-    return AMBIGUOUS.has(symbol.toUpperCase()) ? null : "crypto";
+    return isUnclassifiedTicker("hyperliquid", symbol) ? "unclassified" : "crypto";
 }
 function classifyAster(symbol, subTypes) {
-    if (AMBIGUOUS.has(symbol.toUpperCase()))
-        return null;
+    if (isUnclassifiedTicker("aster", symbol))
+        return "unclassified";
     if (subTypes.includes("pre-launch"))
         return "preIpo";
     if (subTypes.includes("ETF"))
@@ -76,6 +79,10 @@ function warnExcluded(venue, what, symbols) {
     }
 }
 // ── HTTP ──
+/** One public JSON read with the venue error mapping (rate limits, HTTP status, invalid JSON). */
+export async function legacyPublicJson(venue, url, label, init) {
+    return getJson(venue, url, label, init);
+}
 async function getJson(venue, url, label, init) {
     const res = await fetch(url, { ...init, signal: AbortSignal.timeout(15_000) });
     await assertOk(res, `${venue} ${label}`);
@@ -125,7 +132,6 @@ async function pacificaRows(net) {
     const basis = fundingBasisOf("pacifica");
     const settlement = settlementIntervalOf("pacifica");
     const out = [];
-    const unclassified = [];
     const unpriced = [];
     for (const m of info) {
         // /info lists spot markets too (e.g. SOL-USDC): perps only. A row without the field cannot be classified.
@@ -136,10 +142,6 @@ async function pacificaRows(net) {
             continue;
         const symbol = String(m.symbol ?? "");
         const assetClass = classifyPacifica(symbol);
-        if (assetClass === null) {
-            unclassified.push(symbol);
-            continue;
-        }
         const p = priceBySymbol.get(symbol);
         const mark = p ? positiveNumStr(p.mark) : null;
         if (!p || mark === null) {
@@ -158,7 +160,9 @@ async function pacificaRows(net) {
                 quoteAsset: null,
                 markPrice: mark,
                 indexPrice: positiveNumStr(p.oracle),
-                fundingRate: rateStr(p.next_funding),
+                // Last settled hourly rate (WS prices `funding`, the CLI row's fundingRate); next_funding
+                // is the predicted one.
+                fundingRate: rateStr(p.funding),
                 fundingRateBasis: basis,
                 settlementIntervalHours: settlement,
                 openInterest: numStr(p.open_interest),
@@ -172,10 +176,9 @@ async function pacificaRows(net) {
                 session: null,
                 tradable: true,
             },
-            nextFundingTime: null, // Pacifica publishes no next-funding timestamp
+            nextFundingTime: nextTopOfHourMs(), // not published; docs: settled at the end of each 1 h interval (on the hour)
         });
     }
-    warnExcluded("pacifica", "unclassified/ambiguous market(s)", unclassified);
     warnExcluded("pacifica", "market(s) without a mark price", unpriced);
     return out;
 }
@@ -198,7 +201,6 @@ async function hyperliquidRows(net) {
     const basis = fundingBasisOf("hyperliquid");
     const settlement = settlementIntervalOf("hyperliquid");
     const out = [];
-    const unclassified = [];
     const unpriced = [];
     universe.forEach((a, i) => {
         // Delisted assets stay in meta (isDelisted: true) with zeroed funding / volume / OI
@@ -208,10 +210,6 @@ async function hyperliquidRows(net) {
         const ctx = ctxs[i];
         const symbol = String(a.name ?? "");
         const assetClass = classifyHyperliquid(symbol);
-        if (assetClass === null) {
-            unclassified.push(symbol);
-            return;
-        }
         const mark = positiveNumStr(ctx.markPx);
         if (mark === null) {
             unpriced.push(symbol);
@@ -244,10 +242,9 @@ async function hyperliquidRows(net) {
                 session: null,
                 tradable: true, // delisted assets are skipped above
             },
-            nextFundingTime: null, // not published in metaAndAssetCtxs
+            nextFundingTime: nextTopOfHourMs(), // not in metaAndAssetCtxs; docs: paid every hour (on the hour)
         });
     });
-    warnExcluded("hyperliquid", "unclassified/ambiguous market(s)", unclassified);
     warnExcluded("hyperliquid", "market(s) without a mark price", unpriced);
     return out;
 }
@@ -276,20 +273,20 @@ async function asterRows(net) {
             intervalBySymbol.set(String(f.symbol), h);
     }
     const out = [];
-    const unclassified = [];
     const unpriced = [];
     const noInterval = [];
     for (const s of symbols) {
-        if (s.contractType !== "PERPETUAL" || s.quoteAsset !== "USDT")
+        // Shared eligibility (SETTLING / PENDING_TRADING rows were listed with tradable false); every
+        // quote, like the CLI adapter and the WS directory.
+        if (!isAsterListedPerpetual(s))
             continue;
         const venueSymbol = String(s.symbol);
-        const symbol = String(s.baseAsset);
+        const symbol = asterCliSymbol({ symbol: venueSymbol, baseAsset: String(s.baseAsset), quoteAsset: s.quoteAsset });
+        const base = String(s.baseAsset);
         const subTypes = Array.isArray(s.underlyingSubType) ? s.underlyingSubType.map(String) : [];
-        const assetClass = classifyAster(symbol, subTypes);
-        if (assetClass === null) {
-            unclassified.push(venueSymbol);
-            continue;
-        }
+        const assetClass = classifyAster(base, subTypes);
+        // A second listing of a base (BTCUSD1 beside BTCUSDT) or a non-USD quote (U): canonical null.
+        const matchable = asterMatchable(s);
         const p = premiumBySymbol.get(venueSymbol);
         const mark = p ? positiveNumStr(p.markPrice) : null;
         if (!p || mark === null) {
@@ -311,10 +308,10 @@ async function asterRows(net) {
                 venue: "aster",
                 venueSymbol,
                 symbol,
-                canonical: canonicalFor("aster", symbol, assetClass),
+                canonical: matchable ? canonicalFor("aster", base, assetClass) : null,
                 assetClass,
                 settle: s.marginAsset,
-                quoteAsset: s.quoteAsset,
+                quoteAsset: typeof s.quoteAsset === "string" && s.quoteAsset !== "" ? s.quoteAsset : null,
                 markPrice: mark,
                 indexPrice: positiveNumStr(p.indexPrice),
                 fundingRate: rateStr(p.lastFundingRate),
@@ -334,7 +331,6 @@ async function asterRows(net) {
             nextFundingTime: Number.isFinite(next) && next > 0 ? next : null,
         });
     }
-    warnExcluded("aster", "unclassified/ambiguous market(s)", unclassified);
     warnExcluded("aster", "market(s) without a mark price", unpriced);
     warnExcluded("aster", "market(s) missing from fundingInfo", noInterval);
     return out;