perp-cli 0.11.0 → 0.12.1

package/dist/agent-wallet/store.d.ts

@@ -0,0 +1,37 @@
+import type { AgentMeta } from "../settings.js";
+/**
+ * Attempt to acquire the lockfile for an exchange's agent-approve operation.
+ * Returns void on success. Throws LOCK_HELD if another live process holds it.
+ * Auto-clears stale locks (>5 min old OR dead PID).
+ *
+ * Exported so callers can hold the lock across multiple operations (e.g. the
+ * full approve flow) before calling setAgent.
+ */
+export declare function acquireLock(exchange: string): void;
+export declare function releaseLock(exchange: string): void;
+/**
+ * Returns the specific named agent, or the first non-partial agent when
+ * agentName is omitted.
+ */
+export declare function getAgent(exchange: string, agentName?: string): AgentMeta | null;
+/**
+ * Persist an agent meta entry for the given exchange.
+ * Acquires a lockfile before writing to prevent concurrent races (AC-14).
+ *
+ * Re-entrant: if the calling process already holds the lock (e.g. the approve
+ * flow acquired it at the start), this function writes directly without a
+ * double-acquire or release.
+ */
+export declare function setAgent(exchange: string, meta: AgentMeta): void;
+/**
+ * Delete an agent entry. Returns true if it existed and was removed, false if
+ * it was already absent (idempotent per AC-4).
+ */
+export declare function deleteAgent(exchange: string, agentName: string): boolean;
+/**
+ * List all registered agents, optionally filtered to a single exchange.
+ */
+export declare function listAgents(exchange?: string): Array<{
+    exchange: string;
+    meta: AgentMeta;
+}>;

package/dist/agent-wallet/store.js

@@ -0,0 +1,172 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from "fs";
+import { resolve } from "path";
+import { loadSettings, saveSettings } from "../settings.js";
+import { PerpError } from "../errors.js";
+const PERP_DIR = resolve(process.env["HOME"] ?? "~", ".perp");
+const LOCKS_DIR = resolve(PERP_DIR, "locks");
+const LOCK_STALE_MS = 5 * 60 * 1000; // 5 minutes
+function lockPath(exchange) {
+    return resolve(LOCKS_DIR, `agent-approve-${exchange}.lock`);
+}
+/**
+ * Attempt to acquire the lockfile for an exchange's agent-approve operation.
+ * Returns void on success. Throws LOCK_HELD if another live process holds it.
+ * Auto-clears stale locks (>5 min old OR dead PID).
+ *
+ * Exported so callers can hold the lock across multiple operations (e.g. the
+ * full approve flow) before calling setAgent.
+ */
+export function acquireLock(exchange) {
+    mkdirSync(LOCKS_DIR, { recursive: true, mode: 0o700 });
+    const path = lockPath(exchange);
+    if (existsSync(path)) {
+        const contents = readFileSync(path, "utf-8");
+        const [pidStr, tsStr] = contents.trim().split("\n");
+        const pid = parseInt(pidStr ?? "", 10);
+        const ts = tsStr ? new Date(tsStr).getTime() : 0;
+        const age = Date.now() - ts;
+        const isStaleByTime = isNaN(ts) || age > LOCK_STALE_MS;
+        const isDeadPid = !isPidAlive(pid);
+        if (!isStaleByTime && !isDeadPid) {
+            throw new PerpError("LOCK_HELD", `Agent approve lock held by PID ${pid} (started ${tsStr ?? "unknown"})`, {
+                remediation: `Wait 5s and retry, or remove ~/.perp/locks/agent-approve-${exchange}.lock if stale`,
+            });
+        }
+        // Stale lock — clear it
+        unlinkSync(path);
+    }
+    writeFileSync(path, `${process.pid}\n${new Date().toISOString()}`, { mode: 0o600 });
+}
+export function releaseLock(exchange) {
+    const path = lockPath(exchange);
+    try {
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // Best effort — ignore failures on lock release
+    }
+}
+/**
+ * Returns true if the current process already holds the lock for this exchange.
+ * Used by setAgent to implement re-entrant locking.
+ */
+function callerHoldsLock(exchange) {
+    const path = lockPath(exchange);
+    if (!existsSync(path))
+        return false;
+    try {
+        const contents = readFileSync(path, "utf-8");
+        const [pidStr] = contents.trim().split("\n");
+        return parseInt(pidStr ?? "", 10) === process.pid;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check whether a PID is alive via signal 0.
+ *
+ * `process.kill(pid, 0)` throws:
+ *   - ESRCH  → no such process (dead)
+ *   - EPERM  → process exists but we lack permission (alive — e.g. PID 1 on macOS)
+ * Any other error is treated conservatively as "alive" to avoid clearing valid locks.
+ */
+function isPidAlive(pid) {
+    if (isNaN(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // ESRCH = no such process → dead
+        // EPERM = no permission to signal → process IS alive
+        const code = e.code;
+        return code !== "ESRCH";
+    }
+}
+/**
+ * Returns the specific named agent, or the first non-partial agent when
+ * agentName is omitted.
+ */
+export function getAgent(exchange, agentName) {
+    const settings = loadSettings();
+    const byExchange = settings.agents?.[exchange];
+    if (!byExchange)
+        return null;
+    if (agentName !== undefined) {
+        return byExchange[agentName] ?? null;
+    }
+    // Return first non-partial agent
+    for (const meta of Object.values(byExchange)) {
+        if (meta.status !== "partial") {
+            return meta;
+        }
+    }
+    return null;
+}
+/**
+ * Persist an agent meta entry for the given exchange.
+ * Acquires a lockfile before writing to prevent concurrent races (AC-14).
+ *
+ * Re-entrant: if the calling process already holds the lock (e.g. the approve
+ * flow acquired it at the start), this function writes directly without a
+ * double-acquire or release.
+ */
+export function setAgent(exchange, meta) {
+    const alreadyLocked = callerHoldsLock(exchange);
+    if (!alreadyLocked) {
+        acquireLock(exchange);
+    }
+    try {
+        const settings = loadSettings();
+        if (!settings.agents) {
+            settings.agents = {};
+        }
+        const key = exchange;
+        if (!settings.agents[key]) {
+            settings.agents[exchange] = {};
+        }
+        settings.agents[exchange][meta.agentName] = meta;
+        saveSettings(settings);
+    }
+    finally {
+        if (!alreadyLocked) {
+            releaseLock(exchange);
+        }
+    }
+}
+/**
+ * Delete an agent entry. Returns true if it existed and was removed, false if
+ * it was already absent (idempotent per AC-4).
+ */
+export function deleteAgent(exchange, agentName) {
+    const settings = loadSettings();
+    const byExchange = settings.agents?.[exchange];
+    if (!byExchange || !(agentName in byExchange)) {
+        return false;
+    }
+    delete byExchange[agentName];
+    saveSettings(settings);
+    return true;
+}
+/**
+ * List all registered agents, optionally filtered to a single exchange.
+ */
+export function listAgents(exchange) {
+    const settings = loadSettings();
+    if (!settings.agents)
+        return [];
+    const result = [];
+    for (const [ex, agents] of Object.entries(settings.agents)) {
+        if (exchange !== undefined && ex !== exchange)
+            continue;
+        if (agents && typeof agents === "object") {
+            for (const meta of Object.values(agents)) {
+                result.push({ exchange: ex, meta });
+            }
+        }
+    }
+    return result;
+}

package/dist/api/public/_http.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Internal HTTP helpers for the public DEX fetchers.
+ *
+ * SSOT rule #2 boilerplate consolidation: every public fetcher needed the
+ * same 5-line "throw on non-2xx with body excerpt" guard. Centralized here
+ * so each call site is one assertOk(...) line.
+ */
+/**
+ * Throw if the Response is not OK, with HTTP status + (truncated) body
+ * excerpt for diagnostics.
+ *
+ * Use BEFORE `res.json()` so a 5xx JSON error body cannot fulfill as if it
+ * were valid data.
+ */
+export declare function assertOk(res: Response, label: string): Promise<void>;

package/dist/api/public/_http.js

@@ -0,0 +1,24 @@
+/**
+ * Internal HTTP helpers for the public DEX fetchers.
+ *
+ * SSOT rule #2 boilerplate consolidation: every public fetcher needed the
+ * same 5-line "throw on non-2xx with body excerpt" guard. Centralized here
+ * so each call site is one assertOk(...) line.
+ */
+/**
+ * Throw if the Response is not OK, with HTTP status + (truncated) body
+ * excerpt for diagnostics.
+ *
+ * Use BEFORE `res.json()` so a 5xx JSON error body cannot fulfill as if it
+ * were valid data.
+ */
+export async function assertOk(res, label) {
+    if (res.ok)
+        return;
+    let body = "";
+    try {
+        body = await res.text();
+    }
+    catch { /* body read failed; surface status alone */ }
+    throw new Error(`${label} returned HTTP ${res.status}${body ? `: ${body.slice(0, 200)}` : ""}`);
+}

package/dist/api/public/hyperliquid.js

@@ -1,36 +1,44 @@
 import { HYPERLIQUID_API_URL } from "./urls.js";
+import { assertOk } from "./_http.js";
 import { withCache, TTL_MARKET } from "../../cache.js";
 // ── Internal ──
-function hlPost(type) {
-    return fetch(HYPERLIQUID_API_URL, {
+async function hlPost(type) {
+    // SSOT rule #2: a non-2xx response is a real failure, not "no rows" — see assertOk.
+    const res = await fetch(HYPERLIQUID_API_URL, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ type }),
-    }).then(r => r.json());
+    });
+    await assertOk(res, `Hyperliquid info ${type}`);
+    return res.json();
 }
 // ── Fetchers ──
 export function fetchHyperliquidMeta() {
+    // SSOT rule #2: error must propagate. Row-level skipping handles missing
+    // markPx / funding so a 0 doesn't reach downstream comparisons.
     return withCache("pub:hl:metaAndAssetCtxs", TTL_MARKET, async () => {
-        try {
-            const json = await hlPost("metaAndAssetCtxs");
-            const universe = (json[0] ?? {}).universe ?? [];
-            const ctxs = (json[1] ?? []);
-            return universe.map((asset, i) => {
-                const ctx = (ctxs[i] ?? {});
-                return {
-                    symbol: String(asset.name ?? ""),
-                    funding: Number(ctx.funding ?? 0),
-                    markPx: Number(ctx.markPx ?? 0),
-                };
-            });
-        }
-        catch {
-            return [];
-        }
+        const json = await hlPost("metaAndAssetCtxs");
+        const universe = (json[0] ?? {}).universe ?? [];
+        const ctxs = (json[1] ?? []);
+        const out = [];
+        universe.forEach((asset, i) => {
+            const ctx = (ctxs[i] ?? {});
+            const symbol = String(asset.name ?? "");
+            const funding = Number(ctx.funding);
+            const markPx = Number(ctx.markPx);
+            if (!symbol || !Number.isFinite(funding) || !Number.isFinite(markPx) || markPx <= 0)
+                return;
+            out.push({ symbol, funding, markPx });
+        });
+        return out;
     });
 }
 export function fetchHyperliquidMetaRaw() {
-    return withCache("pub:hl:metaAndAssetCtxs:raw", TTL_MARKET, () => hlPost("metaAndAssetCtxs").catch(() => null));
+    // SSOT rule #2: caller is responsible for error handling. Removed silent
+    // `.catch(() => null)` so a network failure surfaces as a rejected Promise.
+    // Callers should wrap with Promise.allSettled to keep multi-DEX comparisons
+    // running when one DEX is down.
+    return withCache("pub:hl:metaAndAssetCtxs:raw", TTL_MARKET, () => hlPost("metaAndAssetCtxs"));
 }
 export function parseHyperliquidMetaRaw(raw) {
     const rates = new Map();
@@ -45,15 +53,19 @@ export function parseHyperliquidMetaRaw(raw) {
         const sym = String(a.name ?? "");
         if (!sym)
             return;
-        rates.set(sym, Number(ctx.funding ?? 0));
-        const mp = Number(ctx.markPx ?? 0);
-        if (mp > 0)
+        // SSOT rule #2: skip rows missing a real funding rate; never publish 0.
+        const funding = Number(ctx.funding);
+        if (Number.isFinite(funding))
+            rates.set(sym, funding);
+        const mp = Number(ctx.markPx);
+        if (Number.isFinite(mp) && mp > 0)
             prices.set(sym, mp);
     });
     return { rates, prices };
 }
 export function fetchHyperliquidAllMidsRaw() {
-    return withCache("pub:hl:allMids:raw", TTL_MARKET, () => hlPost("allMids").catch(() => null));
+    // SSOT rule #2: error must propagate; see fetchHyperliquidMetaRaw.
+    return withCache("pub:hl:allMids:raw", TTL_MARKET, () => hlPost("allMids"));
 }
 // ── Health check ──
 export async function pingHyperliquid() {

package/dist/api/public/lighter.d.ts

@@ -7,7 +7,13 @@ export interface LighterFundingEntry {
     marketId: number;
     symbol: string;
     rate: number;
-    markPrice: number;
+    /**
+     * Lighter's funding-rates endpoint sends mark_price intermittently —
+     * not every row carries it. Consumers must resolve the actual mark price
+     * by falling back to orderBookDetails.lastTradePrice when this is null.
+     * SSOT rule #2 lives at the CONSUMER (resolve or skip), not here.
+     */
+    markPrice: number | null;
 }
 export declare function fetchLighterOrderBookDetails(): Promise<LighterMarketDetail[]>;
 export declare function fetchLighterOrderBookDetailsRaw(): Promise<unknown>;

package/dist/api/public/lighter.js

@@ -1,52 +1,85 @@
 import { LIGHTER_API_URL } from "./urls.js";
+import { assertOk } from "./_http.js";
 import { withCache, TTL_MARKET } from "../../cache.js";
 // ── Fetchers ──
 export function fetchLighterOrderBookDetails() {
+    // SSOT rule #2: error must propagate; callers cannot distinguish "API
+    // returned no markets" from "API down" otherwise. Row-level skipping is
+    // applied for missing/invalid last_trade_price so we never publish a
+    // 0 price downstream.
     return withCache("pub:lt:orderBookDetails", TTL_MARKET, async () => {
-        try {
-            const res = await fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`);
-            const json = await res.json();
-            const details = (json.order_book_details ?? []);
-            return details.map(m => ({
-                marketId: Number(m.market_id),
-                symbol: String(m.symbol ?? ""),
-                lastTradePrice: Number(m.last_trade_price ?? 0),
-            }));
-        }
-        catch {
-            return [];
+        const res = await fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`);
+        await assertOk(res, "Lighter orderBookDetails");
+        const json = await res.json();
+        const details = (json.order_book_details ?? []);
+        const out = [];
+        for (const m of details) {
+            const marketId = Number(m.market_id);
+            const symbol = String(m.symbol ?? "");
+            const lastTradePrice = Number(m.last_trade_price);
+            if (!Number.isFinite(marketId) || !symbol || !Number.isFinite(lastTradePrice) || lastTradePrice <= 0) {
+                continue;
+            }
+            out.push({ marketId, symbol, lastTradePrice });
         }
+        return out;
     });
 }
 export function fetchLighterOrderBookDetailsRaw() {
-    return withCache("pub:lt:orderBookDetails:raw", TTL_MARKET, () => fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`).then(r => r.json()).catch(() => null));
+    // SSOT rule #2: caller (arb / arb-auto) is responsible for error handling.
+    // Removed silent `.catch(() => null)` so a network failure surfaces as a
+    // rejected Promise instead of being indistinguishable from "API returned no
+    // markets". Non-2xx responses are also rejected so a 5xx JSON body cannot
+    // fulfill as if it were valid data.
+    return withCache("pub:lt:orderBookDetails:raw", TTL_MARKET, async () => {
+        const res = await fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`);
+        await assertOk(res, "Lighter orderBookDetails");
+        return res.json();
+    });
 }
 export function fetchLighterFundingRates() {
+    // SSOT rule #2: error must propagate.
+    // Row-level: rate is required (it's the field the endpoint exists for); a
+    // missing rate means the row is malformed and we skip it. mark_price is
+    // documented as intermittent on Lighter's side — when missing, surface as
+    // null so the consumer can apply the orderBookDetails fallback (a
+    // documented price-source preference, NOT an error fallback).
     return withCache("pub:lt:fundingRates", TTL_MARKET, async () => {
-        try {
-            const res = await fetch(`${LIGHTER_API_URL}/api/v1/funding-rates`);
-            const json = await res.json();
-            const list = (json.funding_rates ?? []);
-            const entries = [];
-            for (const fr of list) {
-                if (String(fr.exchange ?? "").toLowerCase() !== "lighter")
-                    continue;
-                entries.push({
-                    marketId: Number(fr.market_id),
-                    symbol: String(fr.symbol ?? ""),
-                    rate: Number(fr.rate ?? fr.funding_rate ?? 0),
-                    markPrice: Number(fr.mark_price ?? 0),
-                });
+        const res = await fetch(`${LIGHTER_API_URL}/api/v1/funding-rates`);
+        await assertOk(res, "Lighter funding-rates");
+        const json = await res.json();
+        const list = (json.funding_rates ?? []);
+        const entries = [];
+        for (const fr of list) {
+            if (String(fr.exchange ?? "").toLowerCase() !== "lighter")
+                continue;
+            const marketId = Number(fr.market_id);
+            // symbol is intentionally allowed to be empty — Lighter's funding-rates
+            // payload often omits symbol per row, and the consumer resolves it from
+            // orderBookDetails by marketId. Required: marketId + valid rate.
+            const symbol = String(fr.symbol ?? "");
+            const rateRaw = fr.rate ?? fr.funding_rate;
+            const rate = Number(rateRaw);
+            if (!Number.isFinite(marketId) || rateRaw === undefined || !Number.isFinite(rate)) {
+                continue;
             }
-            return entries;
-        }
-        catch {
-            return [];
+            const markPriceRaw = fr.mark_price;
+            const markPriceNumber = Number(markPriceRaw);
+            const markPrice = markPriceRaw !== undefined && Number.isFinite(markPriceNumber) && markPriceNumber > 0
+                ? markPriceNumber
+                : null;
+            entries.push({ marketId, symbol, rate, markPrice });
         }
+        return entries;
     });
 }
 export function fetchLighterFundingRatesRaw() {
-    return withCache("pub:lt:fundingRates:raw", TTL_MARKET, () => fetch(`${LIGHTER_API_URL}/api/v1/funding-rates`).then(r => r.json()).catch(() => null));
+    // SSOT rule #2: error must propagate; see fetchLighterOrderBookDetailsRaw.
+    return withCache("pub:lt:fundingRates:raw", TTL_MARKET, async () => {
+        const res = await fetch(`${LIGHTER_API_URL}/api/v1/funding-rates`);
+        await assertOk(res, "Lighter funding-rates");
+        return res.json();
+    });
 }
 export function parseLighterRaw(detailsRaw, fundingRaw) {
     const rates = new Map();
@@ -57,9 +90,13 @@ export function parseLighterRaw(detailsRaw, fundingRaw) {
         const details = (detailsRaw.order_book_details ?? []);
         for (const m of details) {
             const mid = Number(m.market_id);
+            if (!Number.isFinite(mid))
+                continue;
             idToSym.set(mid, String(m.symbol ?? ""));
-            const p = Number(m.last_trade_price ?? 0);
-            if (p > 0)
+            const p = Number(m.last_trade_price);
+            // SSOT rule #2: only register prices that are real positive numbers;
+            // never silently default missing last_trade_price to 0.
+            if (Number.isFinite(p) && p > 0)
                 idToPrice.set(mid, p);
         }
     }
@@ -72,9 +109,20 @@ export function parseLighterRaw(detailsRaw, fundingRaw) {
             const sym = String(fr.symbol ?? "") || idToSym.get(Number(fr.market_id)) || "";
             if (!sym || rates.has(sym))
                 continue;
-            rates.set(sym, Number(fr.rate ?? fr.funding_rate ?? 0));
-            const mp = Number(fr.mark_price ?? 0) || idToPrice.get(Number(fr.market_id)) || 0;
-            if (mp > 0)
+            const rateRaw = fr.rate ?? fr.funding_rate;
+            const rate = Number(rateRaw);
+            // SSOT rule #2: skip rows whose funding rate is missing — never publish 0.
+            if (rateRaw === undefined || !Number.isFinite(rate))
+                continue;
+            rates.set(sym, rate);
+            // Prefer fr.mark_price; fall back to the orderBookDetails last-trade
+            // price as a documented price-source preference (NOT an error fallback).
+            const directMark = Number(fr.mark_price);
+            const fallbackMark = idToPrice.get(Number(fr.market_id));
+            const mp = Number.isFinite(directMark) && directMark > 0
+                ? directMark
+                : (fallbackMark !== undefined && fallbackMark > 0 ? fallbackMark : undefined);
+            if (mp !== undefined)
                 prices.set(sym, mp);
         }
     }

package/dist/api/public/pacifica.js

@@ -1,28 +1,51 @@
 import { PACIFICA_API_URL } from "./urls.js";
+import { assertOk } from "./_http.js";
 import { withCache, TTL_MARKET } from "../../cache.js";
 // ── Fetchers ──
 export function fetchPacificaPrices() {
+    // SSOT rule #2: error must propagate. Row-level skipping is applied for
+    // missing/invalid mark or funding so a 0 doesn't reach downstream paths.
     return withCache("pub:pac:prices", TTL_MARKET, async () => {
-        try {
-            const res = await fetch(PACIFICA_API_URL);
-            const json = await res.json();
-            const data = json.data ?? json;
-            if (!Array.isArray(data))
-                return [];
-            return data.map((p) => ({
-                symbol: String(p.symbol ?? ""),
-                funding: Number(p.next_funding ?? p.funding ?? 0),
-                mark: Number(p.mark ?? 0),
-                nextFunding: p.next_funding ? Number(p.next_funding) : undefined,
-            }));
-        }
-        catch {
+        const res = await fetch(PACIFICA_API_URL);
+        await assertOk(res, "Pacifica prices");
+        const json = await res.json();
+        const data = json.data ?? json;
+        if (!Array.isArray(data))
             return [];
+        const out = [];
+        for (const p of data) {
+            const symbol = String(p.symbol ?? "");
+            const fundingRaw = p.next_funding ?? p.funding;
+            const funding = Number(fundingRaw);
+            const mark = Number(p.mark);
+            if (!symbol || fundingRaw === undefined || !Number.isFinite(funding) || !Number.isFinite(mark) || mark <= 0) {
+                continue;
+            }
+            const nextFundingRaw = p.next_funding;
+            const nextFundingNumber = Number(nextFundingRaw);
+            out.push({
+                symbol,
+                funding,
+                mark,
+                nextFunding: nextFundingRaw !== undefined && Number.isFinite(nextFundingNumber)
+                    ? nextFundingNumber
+                    : undefined,
+            });
         }
+        return out;
     });
 }
 export function fetchPacificaPricesRaw() {
-    return withCache("pub:pac:prices:raw", TTL_MARKET, () => fetch(PACIFICA_API_URL).then(r => r.json()).catch(() => null));
+    // SSOT rule #2: caller is responsible for error handling. Removed silent
+    // `.catch(() => null)` so a network failure surfaces as a rejected Promise.
+    // Callers should wrap with Promise.allSettled to keep multi-DEX comparisons
+    // running when one DEX is down. Non-2xx responses are also rejected so a
+    // 5xx JSON body cannot fulfill as if it were valid data.
+    return withCache("pub:pac:prices:raw", TTL_MARKET, async () => {
+        const res = await fetch(PACIFICA_API_URL);
+        await assertOk(res, "Pacifica prices");
+        return res.json();
+    });
 }
 export function parsePacificaRaw(raw) {
     const rates = new Map();
@@ -34,9 +57,15 @@ export function parsePacificaRaw(raw) {
         const sym = String(p.symbol ?? "");
         if (!sym)
             continue;
-        rates.set(sym, Number(p.next_funding ?? p.funding ?? 0));
-        const mark = Number(p.mark ?? p.price ?? 0);
-        if (mark > 0)
+        // SSOT rule #2: skip rows missing real funding/mark; never publish 0.
+        const fundingRaw = p.next_funding ?? p.funding;
+        const fundingNumber = Number(fundingRaw);
+        if (fundingRaw !== undefined && Number.isFinite(fundingNumber)) {
+            rates.set(sym, fundingNumber);
+        }
+        const markCandidates = [Number(p.mark), Number(p.price)];
+        const mark = markCandidates.find(v => Number.isFinite(v) && v > 0);
+        if (mark !== undefined)
             prices.set(sym, mark);
     }
     return { rates, prices };