perp-cli 0.14.2 → 0.14.3

package/dist/bot/strategies/funding-arb-strategy.js

@@ -7,7 +7,7 @@ import { logExecution, pruneExecutionLog } from "../../execution-log.js";
 import { annualizeHourlyRate } from "../../funding/normalize.js";
 import { getBotSpotAdapter, nonQuoteSpotBalances, readSpotQuoteAvailableFresh, spotNetworkOf, spotTokenBase, sweepSpotQuoteToPerp } from "../../exchanges/spot-factory.js";
 import { getVenue } from "../../exchanges/venue.js";
-import { isPositionGone, transferUsdcToSpot, transferUsdcToPerp, getPerpSymbol, findRate, getPriceEstimate, fetchRates, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols, collectFundingSince } from "./funding-arb-utils.js";
+import { isPositionGone, transferUsdcToSpot, transferUsdcToPerp, getPerpSymbol, findRate, cappedLeverage, getPriceEstimate, fetchRates, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols, collectFundingSince } from "./funding-arb-utils.js";
 import { fillSizeString, sizeDecimalsOf, spotLotStepOf, spotMarketFill } from "../../exchanges/spot-result.js";
 import { floorToStep, lotStepOf } from "../../exchanges/precision.js";
 import { isQuarantined, quarantineKey, quarantineSymbol } from "../quarantine.js";
@@ -637,9 +637,10 @@ export class FundingArbStrategy {
                         continue;
                     // Determine leverage for this symbol
                     const configLeverage = params.leverage ?? 3;
-                    const longMaxLev = findRate(ratesByExchange, best.longExchange, best.symbol)?.maxLeverage ?? 1;
-                    const shortMaxLev = findRate(ratesByExchange, best.shortExchange, best.symbol)?.maxLeverage ?? 1;
-                    const leverage = Math.min(configLeverage, longMaxLev, shortMaxLev);
+                    const leverage = cappedLeverage(configLeverage, [
+                        { exchange: best.longExchange, maxLeverage: findRate(ratesByExchange, best.longExchange, best.symbol)?.maxLeverage },
+                        { exchange: best.shortExchange, maxLeverage: findRate(ratesByExchange, best.shortExchange, best.symbol)?.maxLeverage },
+                    ], ctx.log);
                     // Set leverage on both exchanges before ordering
                     try {
                         await longAdapter.setLeverage(best.symbol, leverage, "cross");
@@ -1020,9 +1021,8 @@ export class FundingArbStrategy {
             const configLeverage = params.leverage ?? 3;
             const perpSymbolUpper = getPerpSymbol(opp.symbol, opp.shortExchange).toUpperCase();
             const perpMaxLev = findRate(ratesByExchange, opp.shortExchange, perpSymbolUpper)?.maxLeverage
-                ?? findRate(ratesByExchange, opp.shortExchange, opp.symbol.toUpperCase())?.maxLeverage
-                ?? 1;
-            const leverage = Math.min(configLeverage, perpMaxLev);
+                ?? findRate(ratesByExchange, opp.shortExchange, opp.symbol.toUpperCase())?.maxLeverage;
+            const leverage = cappedLeverage(configLeverage, [{ exchange: opp.shortExchange, maxLeverage: perpMaxLev }], ctx.log);
             // Set leverage on perp before ordering
             try {
                 await perpAdapter.setLeverage(getPerpSymbol(opp.symbol, opp.shortExchange), leverage, "cross");

package/dist/bot/strategies/funding-arb-utils.d.ts

@@ -47,6 +47,15 @@ export declare function botSpotPerpMatches(spotVenue: string, spotMarkets: reado
 export declare function getPerpSymbol(baseSymbol: string, _exchangeName: string): string;
 /** Look up rate from ratesByExchange, trying symbol, symbol-PERP, and symbol without -PERP. */
 export declare function findRate(ratesByExchange: RateMap, exchange: string, symbol: string): RateEntry | undefined;
+/**
+ * Leverage for an entry: the configured value, capped by every leg's published max.
+ * A leg whose max is unpublished (undefined) is not a cap — the venue enforces its own
+ * limit on setLeverage / the order — and `logUnknown` names it, so it is never read as 1x.
+ */
+export declare function cappedLeverage(configured: number, legs: {
+    exchange: string;
+    maxLeverage: number | undefined;
+}[], logUnknown: (msg: string) => void): number;
 /** Match a symbol against a target, accounting for -PERP suffix variations. */
 export declare function matchSymbol(s: string, target: string): boolean;
 /** Get a price estimate for a symbol from the perp adapter. */
@@ -68,7 +77,11 @@ export interface FundingScore {
  * ORDER_PENDING outcome is never "gone").
  */
 export declare function isPositionGone(e: unknown): boolean;
-/** Score a symbol's funding rate using history. Returns null if insufficient data. */
+/**
+ * Score a symbol's funding rate using history. null = not enough data (fewer than 2 history
+ * points, or the per-symbol funding basis is unknown). A failed read THROWS — callers must not
+ * mistake a 429 / timeout for "history too thin".
+ */
 export declare function scoreFunding(adapter: ExchangeAdapter, symbol: string, exchangeName: string, periods: number, cache?: Map<string, {
     score: FundingScore;
     ts: number;

package/dist/bot/strategies/funding-arb-utils.js

@@ -110,6 +110,23 @@ export function findRate(ratesByExchange, exchange, symbol) {
     const upper = symbol.toUpperCase();
     return map.get(upper) ?? map.get(upper + "-PERP") ?? map.get(upper.replace(/-PERP$/, ""));
 }
+/**
+ * Leverage for an entry: the configured value, capped by every leg's published max.
+ * A leg whose max is unpublished (undefined) is not a cap — the venue enforces its own
+ * limit on setLeverage / the order — and `logUnknown` names it, so it is never read as 1x.
+ */
+export function cappedLeverage(configured, legs, logUnknown) {
+    let leverage = configured;
+    for (const leg of legs) {
+        if (leg.maxLeverage === undefined) {
+            logUnknown(`  [LEV] ${leg.exchange} does not publish a max leverage — using ${configured}x; the venue enforces its cap`);
+        }
+        else {
+            leverage = Math.min(leverage, leg.maxLeverage);
+        }
+    }
+    return leverage;
+}
 /** Match a symbol against a target, accounting for -PERP suffix variations. */
 export function matchSymbol(s, target) {
     const u = s.toUpperCase();
@@ -165,32 +182,33 @@ async function marketFundingHours(adapter, exchangeName, symbol) {
     }
     return getFundingHours(exchangeName);
 }
-/** Score a symbol's funding rate using history. Returns null if insufficient data. */
+/**
+ * Score a symbol's funding rate using history. null = not enough data (fewer than 2 history
+ * points, or the per-symbol funding basis is unknown). A failed read THROWS — callers must not
+ * mistake a 429 / timeout for "history too thin".
+ */
 export async function scoreFunding(adapter, symbol, exchangeName, periods, cache) {
     const key = `${exchangeName}:${symbol}`;
     const cached = cache?.get(key);
     if (cached && Date.now() - cached.ts < 10 * 60 * 1000)
         return cached.score;
-    // Outside the try: an unknown venue is a configuration error, not "no score".
     const venueHours = hasPerSymbolFundingHours(adapter) ? null : getFundingHours(exchangeName);
-    try {
-        const fH = venueHours !== null ? venueHours : await marketFundingHours(adapter, exchangeName, symbol);
-        if (fH === null)
-            return null; // per-symbol basis unknown — the hourly rate would be a guess
-        const history = await adapter.getFundingHistory(symbol, periods);
-        if (history.length < 2)
-            return null;
-        const rates = history.map(h => parseFloat(h.rate));
-        const avgRate = rates.reduce((s, r) => s + r, 0) / rates.length;
-        const consistency = rates.filter(r => r > 0).length / rates.length;
-        const annualized = annualizeHourlyRate(avgRate / fH);
-        const score = { symbol, exchange: exchangeName, avgRate, consistency, annualized, payments: rates.length };
-        cache?.set(key, { score, ts: Date.now() });
-        return score;
-    }
-    catch {
+    const fH = venueHours !== null ? venueHours : await marketFundingHours(adapter, exchangeName, symbol);
+    if (fH === null)
+        return null; // per-symbol basis unknown — the hourly rate would be a guess
+    const history = await adapter.getFundingHistory(symbol, periods);
+    if (history.length < 2)
         return null;
+    const rates = history.map(h => parseFloat(h.rate));
+    if (rates.some(r => !Number.isFinite(r))) {
+        throw new PerpError("EXCHANGE_ERROR", `${exchangeName} ${symbol}: funding history has a non-numeric rate`, { exchange: exchangeName });
     }
+    const avgRate = rates.reduce((s, r) => s + r, 0) / rates.length;
+    const consistency = rates.filter(r => r > 0).length / rates.length;
+    const annualized = annualizeHourlyRate(avgRate / fH);
+    const score = { symbol, exchange: exchangeName, avgRate, consistency, annualized, payments: rates.length };
+    cache?.set(key, { score, ts: Date.now() });
+    return score;
 }
 /**
  * Fetch funding rates from an exchange adapter. Failures propagate — callers
@@ -207,6 +225,7 @@ export async function fetchRates(adapter, exchangeName) {
             continue;
         m.fundingHours = await marketFundingHours(adapter, exchangeName, m.symbol);
     }
+    // maxLeverage undefined = not published by the venue (callers cap by published maxes only — see cappedLeverage).
     const result = [];
     for (const m of withRates) {
         // Skip aster symbols with unknown funding period — the hourly rate would be a guess.
@@ -221,7 +240,7 @@ export async function fetchRates(adapter, exchangeName) {
             rate: parseFloat(m.fundingRate),
             price: parseFloat(m.markPrice),
             sizeDecimals: m.sizeDecimals,
-            maxLeverage: m.maxLeverage,
+            maxLeverage: m.maxLeverage ?? undefined,
             fundingHours: m.fundingHours,
         });
     }

package/dist/bot/strategies/spot-perp-arb-strategy.js

@@ -12,7 +12,7 @@ import { registerStrategy } from "../strategy-registry.js";
 import { getFundingHours } from "../../funding.js";
 import { annualizeHourlyRate } from "../../funding/normalize.js";
 import { pruneExecutionLog } from "../../execution-log.js";
-import { buildAdapterMap, getPerpSymbol, findRate, matchSymbol, fetchRates, scoreFunding, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols, collectFundingSince } from "./funding-arb-utils.js";
+import { buildAdapterMap, getPerpSymbol, findRate, cappedLeverage, matchSymbol, fetchRates, scoreFunding, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols, collectFundingSince } from "./funding-arb-utils.js";
 import { SpotPerpExecutor } from "./spot-perp-executor.js";
 import { findSpotQuoteBalance, getBotSpotAdapter, nonQuoteSpotBalances, spotNetworkOf, spotSharesPerpMargin, spotTokenBase } from "../../exchanges/spot-factory.js";
 import { getVenue } from "../../exchanges/venue.js";
@@ -313,7 +313,7 @@ export class SpotPerpArbStrategy {
             const allowed = allowedByBase.get(pos.symbol.toUpperCase());
             if (allowed === undefined)
                 continue;
-            const candidates = await this.findPerpCandidates(pos.symbol, adapters, ratesByExchange, allowed);
+            const candidates = await this.findPerpCandidates(pos.symbol, adapters, ratesByExchange, allowed, ctx.log);
             const best = candidates[0];
             if (!best || best.exchange === pos.perpExchange)
                 continue;
@@ -331,12 +331,12 @@ export class SpotPerpArbStrategy {
                 continue;
             const perpSym = getPerpSymbol(pos.symbol, pos.perpExchange);
             const newMaxLev = findRate(ratesByExchange, best.exchange, getPerpSymbol(pos.symbol, best.exchange))?.maxLeverage
-                ?? findRate(ratesByExchange, best.exchange, pos.symbol)?.maxLeverage ?? 1;
+                ?? findRate(ratesByExchange, best.exchange, pos.symbol)?.maxLeverage;
             const ok = await this.executor.rotateShort({
                 symbol: pos.symbol, perpSymbol: perpSym,
                 currentExchange: pos.perpExchange, newExchange: best.exchange,
                 currentAdapter: oldAdapter, newAdapter,
-                size: pos.size, leverage: Math.min(p.leverage, newMaxLev), log: ctx.log,
+                size: pos.size, leverage: cappedLeverage(p.leverage, [{ exchange: best.exchange, maxLeverage: newMaxLev }], ctx.log), log: ctx.log,
             });
             if (ok.ok) {
                 // The spot leg is unchanged: the state entry follows the short to its new venue.
@@ -387,7 +387,7 @@ export class SpotPerpArbStrategy {
                         continue;
                     if (this.quarantined(base, ctx))
                         continue;
-                    const candidates = await this.findPerpCandidates(base, adapters, ratesByExchange, allowed);
+                    const candidates = await this.findPerpCandidates(base, adapters, ratesByExchange, allowed, ctx.log);
                     for (const cand of candidates) {
                         if (cand.score.annualized < p.min_rate || cand.score.consistency < p.min_consistency)
                             continue;
@@ -501,7 +501,7 @@ export class SpotPerpArbStrategy {
         return byBase;
     }
     /** Find all perp exchanges for a symbol, sorted by annualized rate (highest first). */
-    async findPerpCandidates(symbol, adapters, ratesByExchange, allowedPerpVenues) {
+    async findPerpCandidates(symbol, adapters, ratesByExchange, allowedPerpVenues, log) {
         const candidates = [];
         for (const [exName, adapter] of adapters) {
             if (!allowedPerpVenues.has(exName))
@@ -510,8 +510,20 @@ export class SpotPerpArbStrategy {
             const ri = findRate(ratesByExchange, exName, perpSym) ?? findRate(ratesByExchange, exName, symbol);
             if (!ri || ri.rate <= 0)
                 continue;
-            const score = await this.scoreFundingLocal(adapter, perpSym, exName)
-                ?? await this.scoreFundingLocal(adapter, symbol, exName);
+            // A failed history read is not "too little history": say so, then try the next symbol form;
+            // a venue with no readable form is left out this cycle.
+            let score = null;
+            for (const sym of perpSym === symbol ? [perpSym] : [perpSym, symbol]) {
+                try {
+                    score = await this.scoreFundingLocal(adapter, sym, exName);
+                }
+                catch (e) {
+                    log(`  [SPA] ${sym} on ${exName}: funding history unreadable — not a candidate this cycle: ${e instanceof Error ? e.message : String(e)}`);
+                    continue;
+                }
+                if (score)
+                    break;
+            }
             if (!score)
                 continue;
             candidates.push({ exchange: exName, rate: ri.rate, score });
@@ -569,8 +581,7 @@ export class SpotPerpArbStrategy {
             const perpSymbol = getPerpSymbol(symbol, perpExchange);
             const rateInfo = findRate(ratesByExchange, perpExchange, perpSymbol)
                 ?? findRate(ratesByExchange, perpExchange, symbol);
-            const perpMaxLev = rateInfo?.maxLeverage ?? 1;
-            const leverage = Math.min(p.leverage, perpMaxLev);
+            const leverage = cappedLeverage(p.leverage, [{ exchange: perpExchange, maxLeverage: rateInfo?.maxLeverage }], ctx.log);
             // Pre-entry: verify fundingHours (aster lazy bootstrap may not have run yet)
             if (perpExchange === "aster" && rateInfo && "getFundingHours" in perpAdapter) {
                 const actualFh = await perpAdapter.getFundingHours(symbol);

package/dist/commands/market.js

@@ -27,7 +27,7 @@ getAccountAdapter) {
             m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A"),
             usdOrDash(m.volume24h),
             usdOrDash(m.openInterest),
-            String(m.maxLeverage) + "x",
+            m.maxLeverage === null ? chalk.gray("-") : String(m.maxLeverage) + "x",
         ];
         // Multi-exchange mode
         if (!explicitExchange && getAdapterForExchange) {
@@ -182,7 +182,7 @@ getAccountAdapter) {
         console.log(`  Funding Rate:   ${m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A")}`);
         console.log(`  24h Volume:     ${usdOrDash(m.volume24h)}`);
         console.log(`  Open Interest:  ${usdOrDash(m.openInterest)}`);
-        console.log(`  Max Leverage:   ${m.maxLeverage}x`);
+        console.log(`  Max Leverage:   ${m.maxLeverage === null ? chalk.gray("-") : `${m.maxLeverage}x`}`);
         console.log();
     });
     market

package/dist/dashboard/ui.js

@@ -334,7 +334,7 @@ function renderPanels(exchanges) {
         return \`<tr>\${isHL?\`<td style="color:var(--purple);font-size:11px">\${dex}</td>\`:''}<td>\${sym}</td><td class="side-\${o.side}">\${o.side.toUpperCase()}</td><td>\${o.type}</td><td>$\${fmt(o.price)}</td><td>\${o.size}</td><td>\${o.filled}</td><td>\${o.status}</td></tr>\`;
       }).join('')}</tbody></table>\`:(ordKnown?'<div class="empty-msg">No open orders</div>':'<div class="empty-msg">Open orders '+NA+'</div>')}
       <div class="section-title">Markets (Top 10)</div>
-      \${ex.topMarkets.length?\`<table><thead><tr><th>Symbol</th><th>Mark</th><th>Index</th><th>Funding</th><th>24h Vol</th><th>OI</th><th>Max Lev</th></tr></thead><tbody>\${ex.topMarkets.map(m=>{const fr=Number(m.fundingRate);return\`<tr><td>\${m.symbol}</td><td>$\${fmt(m.markPrice)}</td><td>\${usdOrDash(m.indexPrice)}</td><td class="\${rateClass(fr)}">\${(fr*100).toFixed(4)}%</td><td>\${usdOrDash(m.volume24h,0)}</td><td>\${usdOrDash(m.openInterest,0)}</td><td>\${m.maxLeverage}x</td></tr>\`;}).join('')}</tbody></table>\`:'<div class="empty-msg">No market data</div>'}
+      \${ex.topMarkets.length?\`<table><thead><tr><th>Symbol</th><th>Mark</th><th>Index</th><th>Funding</th><th>24h Vol</th><th>OI</th><th>Max Lev</th></tr></thead><tbody>\${ex.topMarkets.map(m=>{const fr=Number(m.fundingRate);return\`<tr><td>\${m.symbol}</td><td>$\${fmt(m.markPrice)}</td><td>\${usdOrDash(m.indexPrice)}</td><td class="\${rateClass(fr)}">\${(fr*100).toFixed(4)}%</td><td>\${usdOrDash(m.volume24h,0)}</td><td>\${usdOrDash(m.openInterest,0)}</td><td>\${m.maxLeverage==null?'-':m.maxLeverage+'x'}</td></tr>\`;}).join('')}</tbody></table>\`:'<div class="empty-msg">No market data</div>'}
     </div>\`;
   }).join('');
 

package/dist/exchanges/aster.d.ts

@@ -196,6 +196,11 @@ export declare class AsterAdapter implements ExchangeAdapter {
         rate: string;
         price: string | null;
     }[]>;
+    /**
+     * Candles over [startTime, endTime]. GET /fapi/v3/klines returns at most 1500 bars per request
+     * (1501 → -1130), so the range is read in pages that start after the last bar returned — a long
+     * range is never cut to the first page. More than ASTER_KLINE_MAX_PAGES pages → INVALID_PARAMS.
+     */
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     getBalance(): Promise<ExchangeBalance>;
     /**

package/dist/exchanges/aster.js

@@ -159,6 +159,10 @@ export function requireAsterClientOrderId(id) {
  * that the read refuses (EXCHANGE_ERROR) rather than returning a partial history.
  */
 export const ASTER_INCOME_MAX_PAGES = 60;
+/** GET /fapi/v3/klines maximum rows per request (docs: limit max 1500). */
+const ASTER_KLINE_PAGE = 1500;
+/** Page cap for one range (150 000 bars). */
+const ASTER_KLINE_MAX_PAGES = 100;
 export class AsterAdapter {
     name = "aster";
     chain = "bnb";
@@ -375,41 +379,54 @@ export class AsterAdapter {
             // math depends on.
             this._loadFundingInfo(),
         ]);
+        if (!Array.isArray(info?.symbols)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster exchangeInfo has no symbol list (${JSON.stringify(info).slice(0, 120)})`, { exchange: "aster" });
+        }
+        if (!Array.isArray(tickers)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster 24h ticker is not a list (${JSON.stringify(tickers).slice(0, 120)})`, { exchange: "aster" });
+        }
         const tickerMap = new Map();
-        for (const t of tickers ?? []) {
+        for (const t of tickers) {
             tickerMap.set(String(t.symbol), t);
         }
-        let premiumMap = new Map();
-        try {
-            const premiums = await this._publicGet("/fapi/v3/premiumIndex");
-            premiumMap = new Map(premiums.map(p => [String(p.symbol), p]));
-        }
-        catch { /* non-critical */ }
-        this._ingestPriceFilters(info?.symbols ?? []);
-        const tradingSymbols = (info?.symbols ?? [])
-            .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING");
-        const result = tradingSymbols.map((s) => {
+        // The mark price comes from premiumIndex only: a failed read throws (never a "0" / last-trade
+        // stand-in), and a symbol missing from it is left out of the list below.
+        const premiums = await this._publicGet("/fapi/v3/premiumIndex");
+        if (!Array.isArray(premiums)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster premiumIndex is not a list (${JSON.stringify(premiums).slice(0, 120)})`, { exchange: "aster" });
+        }
+        const premiumMap = new Map(premiums.map(p => [String(p.symbol), p]));
+        this._ingestPriceFilters(info.symbols);
+        // USDT-quoted perps only: the CLI symbol mapping (ETH ↔ ETHUSDT) cannot address the USD1 / U
+        // quoted markets (live 2026-10-13: 22 USD1 + 2 U), so listing them would offer untradeable rows.
+        const tradingSymbols = info.symbols
+            .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING" && String(s.quoteAsset) === "USDT");
+        const result = tradingSymbols.flatMap((s) => {
             const sym = String(s.symbol);
             const ticker = tickerMap.get(sym);
             const premium = premiumMap.get(sym);
-            const maxLev = Number(s.maxLeverage ?? 50);
+            const mark = Number(premium?.markPrice);
+            if (premium === undefined || !(mark > 0))
+                return []; // no published mark price → not listed at 0
+            // Public exchangeInfo carries no leverage (the bracket endpoint is signed) → unknown.
+            const maxLev = null;
             const lotFilter = s.filters
                 ?.find(f => f.filterType === "LOT_SIZE");
             const fundingHours = this._fundingHoursCache.get(this._fromApi(sym));
-            return {
-                symbol: this._fromApi(sym),
-                markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),
-                indexPrice: premium?.indexPrice != null ? String(premium.indexPrice) : null,
-                fundingRate: premium?.lastFundingRate != null ? String(premium.lastFundingRate) : null,
-                volume24h: ticker?.quoteVolume != null ? String(ticker.quoteVolume) : null,
-                // /fapi/v3/exchangeInfo and ticker/24hr carry no open interest.
-                openInterest: null,
-                maxLeverage: maxLev,
-                sizeDecimals: s.quantityPrecision != null ? Number(s.quantityPrecision) : null,
-                stepSize: lotFilter?.stepSize != null ? String(lotFilter.stepSize) : null,
-                fundingHours: fundingHours ?? null,
-                marginTiers: null,
-            };
+            return [{
+                    symbol: this._fromApi(sym),
+                    markPrice: String(premium.markPrice),
+                    indexPrice: premium?.indexPrice != null ? String(premium.indexPrice) : null,
+                    fundingRate: premium?.lastFundingRate != null ? String(premium.lastFundingRate) : null,
+                    volume24h: ticker?.quoteVolume != null ? String(ticker.quoteVolume) : null,
+                    // /fapi/v3/exchangeInfo and ticker/24hr carry no open interest.
+                    openInterest: null,
+                    maxLeverage: maxLev,
+                    sizeDecimals: s.quantityPrecision != null ? Number(s.quantityPrecision) : null,
+                    stepSize: lotFilter?.stepSize != null ? String(lotFilter.stepSize) : null,
+                    fundingHours: fundingHours ?? null,
+                    marginTiers: null,
+                }];
         });
         this._marketsCache = result;
         this._marketsCacheTime = Date.now();
@@ -546,29 +563,64 @@ export class AsterAdapter {
             symbol: this._toApi(symbol),
             limit: String(limit),
         });
-        return (data ?? []).map((d) => ({
-            time: Number(d.fundingTime ?? 0),
-            rate: venueRateField(d.fundingRate, "fundingRate fundingRate", "aster"),
-            price: d.markPrice ? String(d.markPrice) : null,
-        }));
+        if (!Array.isArray(data)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster fundingRate history is not a list (${JSON.stringify(data).slice(0, 120)})`, { exchange: "aster" });
+        }
+        return data.map((d) => {
+            const time = Number(d.fundingTime);
+            if (d.fundingTime === undefined || d.fundingTime === null || !Number.isFinite(time) || time <= 0) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster fundingRate row without a numeric fundingTime: ${JSON.stringify(d).slice(0, 160)}`, { exchange: "aster" });
+            }
+            return {
+                time,
+                rate: venueRateField(d.fundingRate, "fundingRate fundingRate", "aster"),
+                price: d.markPrice ? String(d.markPrice) : null,
+            };
+        });
     }
+    /**
+     * Candles over [startTime, endTime]. GET /fapi/v3/klines returns at most 1500 bars per request
+     * (1501 → -1130), so the range is read in pages that start after the last bar returned — a long
+     * range is never cut to the first page. More than ASTER_KLINE_MAX_PAGES pages → INVALID_PARAMS.
+     */
     async getKlines(symbol, interval, startTime, endTime) {
-        const data = await this._publicGet("/fapi/v3/klines", {
-            symbol: this._toApi(symbol),
-            interval,
-            startTime: String(startTime),
-            endTime: String(endTime),
-            limit: "500",
-        });
-        return (data ?? []).map((k) => ({
-            time: Number(k[0]),
-            open: String(k[1]),
-            high: String(k[2]),
-            low: String(k[3]),
-            close: String(k[4]),
-            volume: String(k[5]),
-            trades: Number(k[8] ?? 0),
-        }));
+        if (!(startTime <= endTime)) {
+            throw new PerpError("INVALID_PARAMS", `Aster klines: start ${startTime} is after end ${endTime}`, {
+                remediation: "Pass a --start that is before --end",
+            });
+        }
+        const out = [];
+        let from = startTime;
+        for (let page = 0; from <= endTime; page++) {
+            if (page >= ASTER_KLINE_MAX_PAGES) {
+                throw new PerpError("INVALID_PARAMS", `Aster: ${interval} candles over this range need more than ${ASTER_KLINE_MAX_PAGES} requests`, {
+                    remediation: "Narrow --start / --end or use a longer interval",
+                });
+            }
+            const data = await this._publicGet("/fapi/v3/klines", {
+                symbol: this._toApi(symbol), interval,
+                startTime: String(from), endTime: String(endTime), limit: String(ASTER_KLINE_PAGE),
+            });
+            if (!Array.isArray(data)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster klines is not a list (${JSON.stringify(data).slice(0, 120)})`, { exchange: "aster" });
+            }
+            for (const k of data) {
+                const time = Number(k[0]);
+                const trades = Number(k[8]);
+                if (!Number.isFinite(time) || !Number.isFinite(trades)) {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster kline row without open time / trade count: ${JSON.stringify(k).slice(0, 120)}`, { exchange: "aster" });
+                }
+                out.push({ time, open: String(k[1]), high: String(k[2]), low: String(k[3]), close: String(k[4]), volume: String(k[5]), trades });
+            }
+            if (data.length < ASTER_KLINE_PAGE)
+                break;
+            const next = Number(data[data.length - 1][0]) + 1;
+            if (next <= from) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster klines page did not advance past ${from}`, { exchange: "aster" });
+            }
+            from = next;
+        }
+        return out;
     }
     // ── Account ──
     async getBalance() {

package/dist/exchanges/hyperliquid.d.ts

@@ -665,10 +665,6 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
      * adapter creation. Throws on a venue rejection (SSOT Rule #2).
      */
     setReferrer(code: string): Promise<unknown>;
-    /**
-     * Get funding history for a symbol.
-     */
-    getFundingHistoryRaw(symbol: string, startTime: number, endTime?: number): Promise<any>;
     /**
      * Get user trade fills.
      */

package/dist/exchanges/hyperliquid.js

@@ -2385,27 +2385,6 @@ export class HyperliquidAdapter {
         }
         return res;
     }
-    /**
-     * Get funding history for a symbol.
-     */
-    async getFundingHistoryRaw(symbol, startTime, endTime) {
-        const baseUrl = this._testnet
-            ? "https://api.hyperliquid-testnet.xyz"
-            : "https://api.hyperliquid.xyz";
-        const body = {
-            type: "fundingHistory",
-            coin: symbol.toUpperCase(),
-            startTime,
-        };
-        if (endTime)
-            body.endTime = endTime;
-        const res = await fetch(`${baseUrl}/info`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-        });
-        return res.json();
-    }
     /**
      * Get user trade fills.
      */

package/dist/exchanges/interface.d.ts

@@ -13,7 +13,8 @@ export interface ExchangeMarketInfo {
     volume24h: string | null;
     /** null = venue does not publish open interest (never "0" as a stand-in) */
     openInterest: string | null;
-    maxLeverage: number;
+    /** null = the venue does not publish it (Aster: the public exchangeInfo carries no leverage) */
+    maxLeverage: number | null;
     /** quantity precision (e.g. 0 = integers only, 2 = 0.01); null = unknown */
     sizeDecimals: number | null;
     /** lot step size (e.g. "1", "0.1", "0.001"); null = unknown */
@@ -38,7 +39,7 @@ export interface ExchangeMarketInfo {
  * A venue that publishes no tiers (`marginTiers === null`) has one flat cap,
  * `maxLeverage`, at every size — that is the venue's definition, not a fallback.
  */
-export declare function maxLeverageForNotional(market: ExchangeMarketInfo, notional: number): number;
+export declare function maxLeverageForNotional(market: ExchangeMarketInfo, notional: number): number | null;
 export interface ExchangePosition {
     symbol: string;
     side: "long" | "short";

package/dist/exchanges/interface.js

@@ -10,8 +10,9 @@ export function maxLeverageForNotional(market, notional) {
     }
     const tiers = market.marginTiers;
     if (tiers === null || tiers.length === 0)
-        return market.maxLeverage;
-    let effective = market.maxLeverage;
+        return market.maxLeverage; // null = not published
+    // No headline but published tiers: the first (lowest-notional) tier is the cap below every threshold.
+    let effective = market.maxLeverage ?? tiers[0].maxLeverage;
     for (const t of tiers) {
         if (notional >= t.lowerBound)
             effective = t.maxLeverage;

package/dist/trade-validator.d.ts

@@ -19,7 +19,7 @@ export interface TradeValidation {
         symbol: string;
         markPrice: number;
         fundingRate: number;
-        maxLeverage: number;
+        maxLeverage: number | null;
     };
     timestamp: string;
 }

package/dist/trade-validator.js

@@ -69,7 +69,12 @@ export async function validateTrade(adapter, params) {
     // reject an order sized past a threshold even though the flat value allows it,
     // so resolve the cap AT THIS ORDER'S NOTIONAL.
     const effectiveMax = maxLeverageForNotional(market, notional);
-    const leverage = params.leverage ?? effectiveMax;
+    // A venue that publishes no max leverage (Aster's public exchangeInfo): the margin estimate
+    // uses 1x — the most conservative requirement — and says so; the venue enforces its own cap.
+    if (effectiveMax === null && params.leverage === undefined) {
+        warnings.push(`Max leverage for ${sym} is not published by ${adapter.name} — margin estimated at 1x; pass --leverage for a tighter estimate`);
+    }
+    const leverage = params.leverage ?? effectiveMax ?? 1;
     if (!Number.isFinite(leverage) || leverage <= 0) {
         throw new Error(`No usable leverage for ${sym} (resolved=${leverage}); supply params.leverage explicitly.`);
     }
@@ -197,7 +202,7 @@ export async function validateTrade(adapter, params) {
     const fee = notional * DEFAULT_TAKER_FEE;
     const estimatedSlippage = params.type === "limit" ? 0 : notional * 0.001;
     const valid = checks.every(c => c.passed);
-    if (leverage > effectiveMax) {
+    if (effectiveMax !== null && market.maxLeverage !== null && leverage > effectiveMax) {
         // Compare against the tier that applies at this notional, not the headline
         // cap — otherwise the check is tautological whenever leverage defaulted FROM
         // maxLeverage, and it never fires for the tiered case it exists to catch.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster, Lighter RH, Ondo Perps, Arcus",
   "bin": {
     "perp": "dist/index.js",

package/skills/perp-cli/SKILL.md

@@ -6,7 +6,7 @@ allowed-tools: "Bash(perp:*), Bash(npx -y perp-cli:*), Bash(bash scripts/preflig
 compatibility: "Requires Node.js 20 or newer and the perp-cli npm package (global install or npx). Network access required for exchange APIs and bridge providers. Mutating commands need a wallet key imported into the OWS vault via 'perp wallet set EXCHANGE' (key on stdin or hidden prompt — never argv). Skill is portable across Claude Code, Claude.ai, Cursor, Codex, and Gemini CLI — no platform-specific features."
 metadata:
   author: hypurrquant
-  version: "0.14.2"
+  version: "0.14.3"
 ---
 
 # perp-cli
@@ -46,7 +46,7 @@ Also bundled under `scripts/`: `preflight.sh`, `arb-monitor.sh`, `funding-analys
 ### Step 1: Verify install + version
 
 ```bash
-perp --version 2>/dev/null || npx -y perp-cli@latest --version   # must be >= 0.14.2
+perp --version 2>/dev/null || npx -y perp-cli@latest --version   # must be >= 0.14.3
 ```
 
 If it is missing or older, ask the user before installing/upgrading (`npm install -g perp-cli@latest`) — never install on your own. If `perp` is not on PATH, prefix every command with `npx -y perp-cli@latest`.