perp-cli 0.9.8 → 0.12.0

package/dist/exchanges/aster.js

@@ -1,36 +1,92 @@
 /**
- * Aster DEX adapter — Binance Futures API compatible REST wrapper.
+ * Aster DEX adapter — EIP-712 three-tier signer routing (v3.2).
+ *
+ * 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)
+ *
+ * HMAC paths fully removed (see Step 3 plan — all Binance-compat HMAC code deleted).
+ *
  * Docs: https://docs.asterdex.com/product/aster-perpetuals/api/api-documentation
  * Base: https://fapi.asterdex.com
  */
-import { createHmac } from "node:crypto";
+import { isExpired } from "../agent-wallet/expiry.js";
+import { classifyError, PerpError } from "../errors.js";
+import { buildOrderTypedData } from "./aster-typed-data.js";
+// ── AsterAdapter ──────────────────────────────────────────────────────────────
 export class AsterAdapter {
     name = "aster";
     chain = "bnb";
     aliases = ["ast"];
-    _apiKey;
-    _apiSecret;
     _baseUrl;
     _testnet;
+    // Signer tiers
+    _agentMeta;
+    _agentSigner; // Tier 1
+    _masterSigner; // Tier 2
+    _pkSigner; // Tier 3
+    _useNoAgent = false;
+    /** PK held between ctor and init() since LocalEvmSigner.create() is async */
+    _pendingPk;
+    // Cache
     _marketsCache = null;
     _marketsCacheTime = 0;
     _fundingHoursCache = new Map();
     _accountCache = null;
     _positionsCache = null;
     _ordersCache = null;
-    static CACHE_TTL = 30_000; // 30 seconds (markets)
-    static ACCOUNT_CACHE_TTL = 5_000; // 5 seconds (account/positions/orders)
-    constructor(apiKey, apiSecret, testnet = false) {
-        this._apiKey = apiKey || process.env.ASTER_API_KEY || "";
-        this._apiSecret = apiSecret || process.env.ASTER_API_SECRET || "";
+    static CACHE_TTL = 30_000;
+    static ACCOUNT_CACHE_TTL = 5_000;
+    // Nonce counter — ensures microsecond-precision uniqueness within process
+    _nonceCounter = 0;
+    constructor(privateKey, testnet = false) {
         this._testnet = testnet;
         this._baseUrl = testnet
             ? (process.env.ASTER_TESTNET_URL || "https://testnet.asterdex.com")
             : "https://fapi.asterdex.com";
+        if (privateKey) {
+            this._pendingPk = privateKey;
+        }
+    }
+    // ── Lifecycle ──
+    async init() {
+        // Verify connectivity by fetching server time
+        await this._publicGet("/fapi/v1/time");
+        // Build LocalEvmSigner from ctor PK now that we're in an async context
+        if (this._pendingPk) {
+            const { LocalEvmSigner } = await import("../signer/index.js");
+            this._pkSigner = await LocalEvmSigner.create(this._pendingPk);
+            this._pendingPk = undefined;
+        }
     }
+    // ── Signer injection ──
+    setAgent(meta, strategy) {
+        this._agentMeta = meta;
+        this._agentSigner = strategy;
+    }
+    setMasterSigner(signer) {
+        this._masterSigner = signer;
+    }
+    setPkSigner(signer) {
+        this._pkSigner = signer;
+    }
+    setNoAgent(noAgent) {
+        this._useNoAgent = noAgent;
+    }
+    // ── Status accessors ──
     get isReadOnly() {
-        return !this._apiKey || !this._apiSecret;
+        return !this._agentSigner && !this._masterSigner && !this._pkSigner;
+    }
+    get activeSignerTier() {
+        try {
+            return this._resolveSigner().tier;
+        }
+        catch {
+            return null;
+        }
     }
+    // ── Symbol helpers ──
     /** CLI symbol → Aster API symbol (ETH → ETHUSDT) */
     _toApi(symbol) {
         const s = symbol.toUpperCase().replace(/-PERP$/, "");
@@ -42,12 +98,8 @@ export class AsterAdapter {
     _fromApi(symbol) {
         return symbol.replace(/USDT$/, "").replace(/BUSD$/, "");
     }
-    async init() {
-        // Verify connectivity by fetching server time
-        await this._publicGet("/fapi/v1/time");
-    }
     // ── Market Data ──
-    /** Get funding interval for a symbol (lazy bootstrap — queries on first access, cached permanently). */
+    /** Get funding interval for a symbol (lazy bootstrap). */
     async getFundingHours(symbol) {
         const key = symbol.toUpperCase();
         const cached = this._fundingHoursCache.get(key);
@@ -64,11 +116,9 @@ export class AsterAdapter {
             }
         }
         catch { /* non-critical */ }
-        // Don't cache a default — let strategy skip this symbol until real data is available
         return undefined;
     }
     async getMarkets() {
-        // Return cached result if fresh
         if (this._marketsCache && Date.now() - this._marketsCacheTime < AsterAdapter.CACHE_TTL) {
             return this._marketsCache;
         }
@@ -80,7 +130,6 @@ export class AsterAdapter {
         for (const t of tickers ?? []) {
             tickerMap.set(String(t.symbol), t);
         }
-        // Also fetch premium index for mark/index/funding
         let premiumMap = new Map();
         try {
             const premiums = await this._publicGet("/fapi/v1/premiumIndex");
@@ -89,17 +138,13 @@ export class AsterAdapter {
         catch { /* non-critical */ }
         const tradingSymbols = (info?.symbols ?? [])
             .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING");
-        // OI is fetched lazily per symbol (see getMarketInfo) to avoid 300+ API calls
-        const result = tradingSymbols
-            .map((s) => {
+        const result = tradingSymbols.map((s) => {
             const sym = String(s.symbol);
             const ticker = tickerMap.get(sym);
             const premium = premiumMap.get(sym);
             const maxLev = Number(s.maxLeverage ?? 50);
             const lotFilter = s.filters
                 ?.find(f => f.filterType === "LOT_SIZE");
-            // Use cached funding interval if available (populated by getFundingHours()).
-            // If not yet bootstrapped, fundingHours = undefined → strategy must skip this symbol.
             const fundingHours = this._fundingHoursCache.get(this._fromApi(sym));
             return {
                 symbol: this._fromApi(sym),
@@ -173,7 +218,9 @@ export class AsterAdapter {
         if (this._accountCache && Date.now() - this._accountCache.time < AsterAdapter.ACCOUNT_CACHE_TTL) {
             return this._accountCache.data;
         }
-        const account = await this._signedGet("/fapi/v2/account");
+        const r = this._resolveSigner();
+        // v3: /fapi/v2/account is HMAC-only; v3 EIP-712 uses /fapi/v3/accountWithJoinMargin.
+        const account = await this._signedGetEip712("/fapi/v3/accountWithJoinMargin", {}, r);
         const totalWallet = Number(account.totalWalletBalance ?? 0);
         const unrealizedPnl = Number(account.totalUnrealizedProfit ?? 0);
         const available = Number(account.availableBalance ?? 0);
@@ -191,19 +238,35 @@ export class AsterAdapter {
         if (this._positionsCache && Date.now() - this._positionsCache.time < AsterAdapter.ACCOUNT_CACHE_TTL) {
             return this._positionsCache.data;
         }
-        const data = await this._signedGet("/fapi/v2/positionRisk");
-        const result = (data ?? [])
-            .filter((p) => Number(p.positionAmt ?? 0) !== 0)
-            .map((p) => {
+        const r = this._resolveSigner();
+        // v3: /fapi/v2/positionRisk has no v3 equivalent. Positions live inside
+        // /fapi/v3/accountWithJoinMargin under `positions`. Mark price + liquidation
+        // price are NOT included there — fetch from the public premiumIndex.
+        const account = await this._signedGetEip712("/fapi/v3/accountWithJoinMargin", {}, r);
+        const positions = account.positions ?? [];
+        const open = positions.filter((p) => Number(p.positionAmt ?? 0) !== 0);
+        // Fetch mark prices for the open symbols (best-effort; non-fatal on failure)
+        const markMap = new Map();
+        if (open.length > 0) {
+            try {
+                const premiums = await this._publicGet("/fapi/v1/premiumIndex");
+                for (const p of premiums ?? []) {
+                    markMap.set(String(p.symbol), String(p.markPrice ?? "0"));
+                }
+            }
+            catch { /* non-critical */ }
+        }
+        const result = open.map((p) => {
             const amt = Number(p.positionAmt ?? 0);
+            const apiSym = String(p.symbol ?? "");
             return {
-                symbol: this._fromApi(String(p.symbol ?? "")),
+                symbol: this._fromApi(apiSym),
                 side: amt > 0 ? "long" : "short",
                 size: String(Math.abs(amt)),
                 entryPrice: String(p.entryPrice ?? "0"),
-                markPrice: String(p.markPrice ?? "0"),
-                liquidationPrice: String(p.liquidationPrice ?? "0"),
-                unrealizedPnl: String(p.unRealizedProfit ?? "0"),
+                markPrice: markMap.get(apiSym) ?? "0",
+                liquidationPrice: "0", // v3 accountWithJoinMargin does not expose this
+                unrealizedPnl: String(p.unrealizedProfit ?? "0"),
                 leverage: Number(p.leverage ?? 1),
             };
         });
@@ -214,7 +277,8 @@ export class AsterAdapter {
         if (this._ordersCache && Date.now() - this._ordersCache.time < AsterAdapter.ACCOUNT_CACHE_TTL) {
             return this._ordersCache.data;
         }
-        const orders = await this._signedGet("/fapi/v1/openOrders");
+        const r = this._resolveSigner();
+        const orders = await this._signedGetEip712("/fapi/v3/openOrders", {}, r);
         const result = (orders ?? []).map((o) => ({
             orderId: String(o.orderId ?? ""),
             symbol: this._fromApi(String(o.symbol ?? "")),
@@ -229,22 +293,21 @@ export class AsterAdapter {
         return result;
     }
     async getOrderHistory(limit = 30) {
-        // allOrders requires symbol — get from positions or recent trades
         const positions = await this.getPositions();
         const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
         if (apiSymbols.size === 0) {
-            // Fallback: query the most common perp symbols when no open positions exist
             for (const s of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT"]) {
                 apiSymbols.add(s);
             }
         }
+        const r = this._resolveSigner();
         const allOrders = [];
         for (const sym of apiSymbols) {
             try {
-                const orders = await this._signedGet("/fapi/v1/allOrders", {
+                const orders = await this._signedGetEip712("/fapi/v3/allOrders", {
                     symbol: sym,
                     limit: String(limit),
-                });
+                }, r);
                 for (const o of orders ?? []) {
                     allOrders.push({
                         orderId: String(o.orderId ?? ""),
@@ -267,13 +330,14 @@ export class AsterAdapter {
         const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
         if (apiSymbols.size === 0)
             apiSymbols.add("BTCUSDT");
+        const r = this._resolveSigner();
         const allTrades = [];
         for (const sym of apiSymbols) {
             try {
-                const trades = await this._signedGet("/fapi/v1/userTrades", {
+                const trades = await this._signedGetEip712("/fapi/v3/userTrades", {
                     symbol: sym,
                     limit: String(limit),
-                });
+                }, r);
                 for (const t of trades ?? []) {
                     allTrades.push({
                         time: Number(t.time ?? 0),
@@ -290,10 +354,11 @@ export class AsterAdapter {
         return allTrades.sort((a, b) => b.time - a.time).slice(0, limit);
     }
     async getFundingPayments(limit = 200) {
-        const data = await this._signedGet("/fapi/v1/income", {
+        const r = this._resolveSigner();
+        const data = await this._signedGetEip712("/fapi/v3/income", {
             incomeType: "FUNDING_FEE",
             limit: String(limit),
-        });
+        }, r);
         return (data ?? []).map((f) => ({
             time: Number(f.time ?? 0),
             symbol: this._fromApi(String(f.symbol ?? "")),
@@ -302,6 +367,7 @@ export class AsterAdapter {
     }
     // ── Trading ──
     async marketOrder(symbol, side, size, opts) {
+        const r = this._resolveSigner();
         const apiSymbol = this._toApi(symbol);
         const params = {
             symbol: apiSymbol,
@@ -311,25 +377,23 @@ export class AsterAdapter {
         };
         if (opts?.reduceOnly)
             params.reduceOnly = "true";
-        const result = await this._signedPost("/fapi/v1/order", params);
-        const r = result;
-        const executedQty = Number(r.executedQty ?? 0);
-        const orderId = String(r.orderId ?? "");
-        // If immediately filled, return
-        if (executedQty > 0 && r.status === "FILLED")
+        const result = await this._signedPostEip712("/fapi/v3/order", params, r);
+        const ro = result;
+        const executedQty = Number(ro.executedQty ?? 0);
+        const orderId = String(ro.orderId ?? "");
+        if (executedQty > 0 && ro.status === "FILLED")
             return result;
-        // status=NEW: order accepted but not yet filled — poll for up to 3 seconds
-        if (r.status === "NEW" && orderId) {
+        if (ro.status === "NEW" && orderId) {
             for (let i = 0; i < 3; i++) {
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                await new Promise(res => setTimeout(res, 1000));
                 try {
-                    const check = await this._signedGet("/fapi/v1/order", {
+                    const check = await this._signedGetEip712("/fapi/v3/order", {
                         symbol: apiSymbol,
                         orderId,
-                    });
+                    }, r);
                     const filledQty = Number(check.executedQty ?? 0);
                     if (filledQty > 0)
-                        return check; // filled
+                        return check;
                     if (check.status === "CANCELED" || check.status === "EXPIRED" || check.status === "REJECTED") {
                         throw new Error(`Market ${side} ${symbol}: order ${check.status} (orderId: ${orderId})`);
                     }
@@ -337,23 +401,21 @@ export class AsterAdapter {
                 catch (e) {
                     if (e instanceof Error && e.message.startsWith("Market "))
                         throw e;
-                    // query failed, retry
                 }
             }
-            // Still not filled after 3s — cancel and throw
             try {
-                await this._signedDelete("/fapi/v1/order", { symbol: apiSymbol, orderId });
+                await this._signedDeleteEip712("/fapi/v3/order", { symbol: apiSymbol, orderId }, r);
             }
             catch { /* best effort cancel */ }
             throw new Error(`Market ${side} ${symbol}: order not filled after 3s, cancelled (orderId: ${orderId})`);
         }
-        // executedQty === 0 with non-NEW status
         if (executedQty === 0) {
-            throw new Error(`Market ${side} ${symbol}: order accepted but 0 filled (status: ${r.status}, orderId: ${orderId})`);
+            throw new Error(`Market ${side} ${symbol}: order accepted but 0 filled (status: ${ro.status}, orderId: ${orderId})`);
         }
         return result;
     }
     async limitOrder(symbol, side, price, size, opts) {
+        const r = this._resolveSigner();
         const params = {
             symbol: this._toApi(symbol),
             side: side.toUpperCase(),
@@ -364,7 +426,7 @@ export class AsterAdapter {
         };
         if (opts?.reduceOnly)
             params.reduceOnly = "true";
-        return this._signedPost("/fapi/v1/order", params);
+        return this._signedPostEip712("/fapi/v3/order", params, r);
     }
     async editOrder(symbol, orderId, price, size) {
         // Aster has no atomic edit — cancel + replace
@@ -375,44 +437,44 @@ export class AsterAdapter {
         return this.limitOrder(symbol, side, price, size);
     }
     async cancelOrder(symbol, orderId) {
-        return this._signedDelete("/fapi/v1/order", {
+        const r = this._resolveSigner();
+        return this._signedDeleteEip712("/fapi/v3/order", {
             symbol: this._toApi(symbol),
             orderId,
-        });
+        }, r);
     }
     async cancelAllOrders(symbol) {
+        const r = this._resolveSigner();
         if (!symbol) {
-            // Cancel all for all symbols with open orders
             const orders = await this.getOpenOrders();
             const apiSymbols = new Set(orders.map(o => this._toApi(o.symbol)));
             const results = [];
             for (const sym of apiSymbols) {
-                results.push(await this._signedDelete("/fapi/v1/allOpenOrders", { symbol: sym }));
+                results.push(await this._signedDeleteEip712("/fapi/v3/allOpenOrders", { symbol: sym }, r));
             }
             return results;
         }
-        return this._signedDelete("/fapi/v1/allOpenOrders", { symbol: this._toApi(symbol) });
+        return this._signedDeleteEip712("/fapi/v3/allOpenOrders", { symbol: this._toApi(symbol) }, r);
     }
     // ── Risk ──
     async setLeverage(symbol, leverage, marginMode) {
-        // Set margin type first if specified
+        const r = this._resolveSigner();
         if (marginMode) {
             try {
-                await this._signedPost("/fapi/v1/marginType", {
+                await this._signedPostEip712("/fapi/v3/marginType", {
                     symbol: this._toApi(symbol),
                     marginType: marginMode === "cross" ? "CROSSED" : "ISOLATED",
-                });
-            }
-            catch {
-                // May fail if already set — non-critical
+                }, r);
             }
+            catch { /* may fail if already set */ }
         }
-        return this._signedPost("/fapi/v1/leverage", {
+        return this._signedPostEip712("/fapi/v3/leverage", {
             symbol: this._toApi(symbol),
             leverage: String(leverage),
-        });
+        }, r);
     }
     async stopOrder(symbol, side, size, triggerPrice, opts) {
+        const r = this._resolveSigner();
         const params = {
             symbol: this._toApi(symbol),
             side: side.toUpperCase(),
@@ -426,26 +488,155 @@ export class AsterAdapter {
         }
         if (opts?.reduceOnly)
             params.reduceOnly = "true";
-        return this._signedPost("/fapi/v1/order", params);
+        return this._signedPostEip712("/fapi/v3/order", params, r);
     }
-    // ── Withdraw (unified interface) ──
+    // ── Withdraw (master-only: never delegates to agent or PK) ──
     async withdraw(amount, _destination, _opts) {
-        // Aster withdrawal is via separate spot/wallet API, not futures API
+        if (!this._masterSigner) {
+            throw new PerpError("NO_SIGNER_AVAILABLE", "Aster withdrawal requires OWS master wallet (--ows). Agent and PK signers cannot authorize withdrawals.", {
+                remediation: "Use: perp -e aster --ows <walletName> funds withdraw",
+            });
+        }
+        // Aster withdrawal via spot/wallet API (not futures API) — not yet implemented.
         throw new Error("Aster withdrawal requires the spot API (not available in futures mode). Use the Aster web UI to withdraw.");
     }
-    // ── Internal HTTP helpers ──
-    _sign(params) {
-        params.timestamp = String(Date.now());
-        params.recvWindow = "5000";
-        const queryString = Object.entries(params)
-            .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
-            .join("&");
-        const signature = createHmac("sha256", this._apiSecret)
-            .update(queryString)
-            .digest("hex");
-        return `${queryString}&signature=${signature}`;
+    // ── Private: signer resolution ────────────────────────────────────────────
+    _resolveSigner() {
+        // Tier 1: agent (when registered, not expired, --no-agent NOT set)
+        if (!this._useNoAgent && this._agentSigner && this._agentMeta) {
+            if (isExpired(this._agentMeta)) {
+                // Skip Tier 1 only if Tier 2/3 available; otherwise throw AGENT_EXPIRED
+                if (!this._masterSigner && !this._pkSigner) {
+                    throw new PerpError("AGENT_EXPIRED", "Agent wallet has expired", {
+                        remediation: "perp wallet agent approve aster --rotate",
+                    });
+                }
+                // fall through to Tier 2/3
+            }
+            else {
+                return {
+                    tier: "agent",
+                    signer: this._agentSigner,
+                    signerAddress: this._agentMeta.agentEvmAddress,
+                    userAddress: this._agentMeta.userEvmAddress,
+                };
+            }
+        }
+        // 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 };
+        }
+        // No signer at any tier
+        throw new PerpError("NO_SIGNER_AVAILABLE", "No signing path configured for Aster", {
+            remediation: "Run one of: (a) perp wallet agent approve aster --master <wallet>; (b) perp wallet generate && perp -e aster --ows <wallet>; (c) export ASTER_PRIVATE_KEY=0x...",
+        });
+    }
+    // ── Private: nonce ────────────────────────────────────────────────────────
+    _nextNonce() {
+        const ms = Date.now() * 1000 + (++this._nonceCounter % 1000);
+        return String(ms);
+    }
+    // ── Private: EIP-712 signed HTTP helpers ─────────────────────────────────
+    /**
+     * Build the canonical signed-request URL per Aster v3 spec.
+     *
+     * Reference: https://github.com/asterdex/api-docs (V3, EN, send_by_url).
+     * The Python reference adds keys to the dict in this exact order:
+     *   nonce, user, signer
+     * then URL-encodes the dict to form the EIP-712 `msg`. After signing,
+     * `&signature=` is appended to the same query string. Authority verification
+     * reconstructs `msg` from the URL query params minus `signature`, so the
+     * signed dict and the URL query string must be byte-identical except for
+     * the appended signature.
+     *
+     * `signatureChainId` is NOT a v3 parameter — it's an artifact of an older
+     * scheme; including it breaks signature verification on every call.
+     */
+    async _buildSignedQueryString(params, resolved) {
+        // Insertion order (matches Python reference: nonce, user, signer last).
+        const fullParams = {
+            ...params,
+            nonce: this._nextNonce(),
+            user: resolved.userAddress,
+            signer: resolved.signerAddress,
+        };
+        const typed = buildOrderTypedData(fullParams);
+        // 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
+        const sigHex = typeof sigRaw === "string" ? sigRaw : sigRaw.signature;
+        // typed.message.msg is the URL-encoded dict in the same order; reuse it
+        // to guarantee the byte-identical query string is sent on the wire.
+        return `${typed.message.msg}&signature=${sigHex}`;
+    }
+    /**
+     * Sign and POST to a path using EIP-712 Domain B.
+     */
+    async _signedPostEip712(path, params, resolved) {
+        const qs = await this._buildSignedQueryString(params, resolved);
+        const url = `${this._baseUrl}${path}?${qs}`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: "",
+        });
+        return this._handleEip712Response(res, "POST", path);
     }
-    /** Handle 429 rate limit with retry */
+    /**
+     * Sign and GET from a path using EIP-712 Domain B.
+     */
+    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`);
+    }
+    /**
+     * Sign and DELETE from a path using EIP-712 Domain B.
+     */
+    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;
+        }
+        throw new Error(`DELETE ${path} failed: max retries exceeded`);
+    }
+    // ── Private: HTTP response handling ──────────────────────────────────────
+    async _handleEip712Response(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)));
+            throw new Error(`${method} ${path} rate limited`);
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            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 });
+        }
+        return json;
+    }
+    /** Handle 429 rate limit with retry — used by GET/DELETE multi-attempt loops */
     async _handleResponse(res, method, path, attempt = 0) {
         if (res.status === 429) {
             if (attempt >= 2)
@@ -475,53 +666,4 @@ export class AsterAdapter {
         }
         throw new Error(`GET ${path} failed: max retries exceeded`);
     }
-    async _signedGet(path, params = {}) {
-        if (this.isReadOnly)
-            throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const signed = this._sign({ ...params });
-            const url = `${this._baseUrl}${path}?${signed}`;
-            const res = await fetch(url, {
-                headers: { "X-MBX-APIKEY": this._apiKey },
-            });
-            const result = await this._handleResponse(res, "GET", path, attempt);
-            if (result !== null)
-                return result;
-        }
-        throw new Error(`GET ${path} failed: max retries exceeded`);
-    }
-    async _signedPost(path, params = {}) {
-        if (this.isReadOnly)
-            throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const signed = this._sign({ ...params });
-            const res = await fetch(`${this._baseUrl}${path}`, {
-                method: "POST",
-                headers: {
-                    "X-MBX-APIKEY": this._apiKey,
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-                body: signed,
-            });
-            const result = await this._handleResponse(res, "POST", path, attempt);
-            if (result !== null)
-                return result;
-        }
-        throw new Error(`POST ${path} failed: max retries exceeded`);
-    }
-    async _signedDelete(path, params = {}) {
-        if (this.isReadOnly)
-            throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
-        for (let attempt = 0; attempt < 3; attempt++) {
-            const signed = this._sign({ ...params });
-            const res = await fetch(`${this._baseUrl}${path}?${signed}`, {
-                method: "DELETE",
-                headers: { "X-MBX-APIKEY": this._apiKey },
-            });
-            const result = await this._handleResponse(res, "DELETE", path, attempt);
-            if (result !== null)
-                return result;
-        }
-        throw new Error(`DELETE ${path} failed: max retries exceeded`);
-    }
 }