perp-cli 0.12.17 → 0.14.1

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

@@ -68,7 +68,7 @@ export interface ApproveAgentParams {
     builderName?: string;
     /** Microsecond-precision nonce (Date.now() * 1000 + counter). Serialized as decimal string. */
     nonceMicros: number | string;
-    asterChain?: AsterChain;
+    asterChain: AsterChain;
 }
 /**
  * Build the EIP-712 typed-data payload for `POST /fapi/v3/approveAgent`.
@@ -90,15 +90,19 @@ export interface DelAgentParams {
     user: `0x${string}`;
     agentAddress: `0x${string}`;
     nonceMicros: number | string;
-    asterChain?: AsterChain;
+    asterChain: AsterChain;
 }
 /**
  * Build the EIP-712 typed-data payload for `DELETE /fapi/v3/agent`.
  *
- * TODO: confirm DelAgent struct vs Aster docs at Step 0b spike.
- * HypurrQuant_FE does not implement a revoke/delAgent method — this is a
- * best-effort field set mirroring the ApproveAgent terminal fields (AgentAddress,
- * AsterChain, User, Nonce) without the permission booleans.
+ * OPEN ITEM (docs/TEST-PLAN.md "Aster DelAgent struct — mainnet verification"): the
+ * public Aster V3 docs (asterdex/api-docs, futures api v3 + testnet, checked 2026-10-02)
+ * document no agent-delete endpoint or DelAgent struct, and HypurrQuant_FE has no
+ * revoke method. This field set mirrors the ApproveAgent terminal fields (AgentAddress,
+ * AsterChain, User, Nonce) without the permission booleans. It is only reachable on
+ * mainnet (assertAgentApproveSupported refuses Aster agent management on testnet), and
+ * revoke treats any non-confirming venue response as APPROVE_FAILED (assertAsterAgentDeleted),
+ * so a wrong struct fails loudly instead of reporting a false revoke.
  */
 export declare function buildDelAgentTypedData(params: DelAgentParams): {
     domain: typeof ASTER_DOMAIN_A;
@@ -143,7 +147,7 @@ export interface ApproveBuilderParams {
     builderName?: string;
     user: `0x${string}`;
     nonceMicros: number | string;
-    asterChain?: AsterChain;
+    asterChain: AsterChain;
 }
 /**
  * Build the EIP-712 typed-data payload for `POST /fapi/v3/approveBuilder`.
@@ -166,4 +170,126 @@ export declare function buildApproveBuilderTypedData(params: ApproveBuilderParam
     primaryType: "ApproveBuilder";
     message: Record<string, unknown>;
 };
+export interface DelBuilderParams {
+    builder: string;
+    user: `0x${string}`;
+    nonceMicros: number | string;
+    asterChain: AsterChain;
+}
+/**
+ * EIP-712 payload for `DELETE /fapi/v3/builder` (revoke a builder approval).
+ * Source: asterdex/api-docs demo/aster-code.py `delBuilder` — main-wallet signed,
+ * primaryType "DelBuilder", fields = the request params with the first letter
+ * upper-cased in insertion order: Builder, AsterChain, User, Nonce (Domain A).
+ */
+export declare function buildDelBuilderTypedData(params: DelBuilderParams): {
+    domain: typeof ASTER_DOMAIN_A;
+    types: {
+        DelBuilder: Eip712Field[];
+    };
+    primaryType: "DelBuilder";
+    message: Record<string, unknown>;
+};
+/** signatureChainId for an EVM `user` on POST /fapi/v3/registerAndApproveAgent (101 = Solana). */
+export declare const ASTER_REGISTER_AGENT_EVM_CHAIN_ID = 56;
+export interface RegisterAndApproveAgentParams {
+    user: `0x${string}`;
+    /** Microsecond timestamp; server tolerance ±10 s, never reused. */
+    nonceMicros: number | string;
+    agentName: string;
+    agentAddress: `0x${string}`;
+    /** Agent expiry, Unix milliseconds. */
+    expiredMs: number | string;
+    signatureChainId: number;
+    canSpotTrade: boolean;
+    canPerpTrade: boolean;
+    canWithdraw: boolean;
+    /** Space-delimited IPs / CIDRs; "" when none. Must be non-empty when canWithdraw. */
+    ipWhitelist: string;
+}
+/**
+ * EIP-712 payload for `POST /fapi/v3/registerAndApproveAgent` (asterdex/api-docs
+ * eeddec8, V3 futures v3 + testnet, added 2026-05-12). Unauthenticated endpoint;
+ * the user's wallet signs the literal (not URL-encoded) parameter string
+ *   user=…&nonce=…&agentName=…&agentAddress=…&expired=…&signatureChainId=…&canSpotTrade=…&canPerpTrade=…&canWithdraw=…&ipWhitelist=…
+ * wrapped as Message{msg} under domain AsterSignTransaction / v1 / chainId =
+ * signatureChainId (56 for EVM) / zero verifyingContract. Unlike approveAgent
+ * this carries no AsterChain field — the host selects the network.
+ */
+export declare function buildRegisterAndApproveAgentTypedData(params: RegisterAndApproveAgentParams): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+    types: typeof ORDER_TYPES;
+    primaryType: "Message";
+    message: {
+        msg: string;
+    };
+    /** Request parameters in signing order (the caller appends `signature`). */
+    params: [string, string][];
+};
+/** EIP-712 types of the EVM withdraw signature (field names contain spaces — they are part of the type hash). */
+export declare const ASTER_WITHDRAW_TYPES: {
+    readonly Action: readonly [{
+        readonly name: "type";
+        readonly type: "string";
+    }, {
+        readonly name: "destination";
+        readonly type: "address";
+    }, {
+        readonly name: "destination Chain";
+        readonly type: "string";
+    }, {
+        readonly name: "token";
+        readonly type: "string";
+    }, {
+        readonly name: "amount";
+        readonly type: "string";
+    }, {
+        readonly name: "fee";
+        readonly type: "string";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "aster chain";
+        readonly type: "string";
+    }];
+};
+export interface WithdrawTypedDataParams {
+    /** Destination chain id — also the EIP-712 domain chainId (docs: "The chainId of the withdraw chain"). */
+    chainId: number;
+    /** `destination Chain` name: 1 → "ETH", 56 → "BSC", 42161 → "Arbitrum". */
+    chainName: string;
+    /** Receipt address — the account's own registered address. */
+    receiver: string;
+    /** Currency name, e.g. "USDT". */
+    asset: string;
+    /** Amount in token units, the SAME string sent as the `amount` request param. */
+    amount: string;
+    /** Fee in token units, the SAME string sent as the `fee` request param. */
+    fee: string;
+    /** ms timestamp × 1000, decimal string; sent as the `userNonce` request param. */
+    userNonce: string;
+}
+/**
+ * Master-signed EVM withdraw signature (`userSignature` of POST /fapi/v3/aster/user-withdraw).
+ * Source: asterdex/api-docs demo/aster-deposit-withdrawal.md "EVM Withdraw Signature" and
+ * asterdex/API-demo futures-v3-demo/58_withdrawEvm.js. Domain name "Aster" (NOT the
+ * "AsterSignTransaction" API-auth domain); `aster chain` is the fixed string "Mainnet".
+ */
+export declare function buildWithdrawTypedData(p: WithdrawTypedDataParams): {
+    domain: {
+        name: "Aster";
+        version: "1";
+        chainId: number;
+        verifyingContract: string;
+    };
+    types: typeof ASTER_WITHDRAW_TYPES;
+    primaryType: "Action";
+    message: Record<string, string>;
+};
 export {};

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

@@ -11,6 +11,7 @@
  *   - uint256 fields serialized as decimal strings (never BigInt) to survive JSON.stringify
  *   - EIP-712 message keys are PascalCase; HTTP query-string keys are camelCase
  */
+import { PerpError } from "../errors.js";
 // ── Domain constants ──────────────────────────────────────────────────────────
 /** Domain A: used for master-signed ops (ApproveAgent, DelAgent, ApproveBuilder). */
 export const ASTER_DOMAIN_A = {
@@ -85,7 +86,7 @@ export function buildApproveAgentTypedData(params) {
             message["BuilderName"] = params.builderName;
         }
     }
-    message["AsterChain"] = params.asterChain ?? "Mainnet";
+    message["AsterChain"] = params.asterChain;
     message["User"] = params.user;
     message["Nonce"] = String(params.nonceMicros);
     return {
@@ -98,10 +99,14 @@ export function buildApproveAgentTypedData(params) {
 /**
  * Build the EIP-712 typed-data payload for `DELETE /fapi/v3/agent`.
  *
- * TODO: confirm DelAgent struct vs Aster docs at Step 0b spike.
- * HypurrQuant_FE does not implement a revoke/delAgent method — this is a
- * best-effort field set mirroring the ApproveAgent terminal fields (AgentAddress,
- * AsterChain, User, Nonce) without the permission booleans.
+ * OPEN ITEM (docs/TEST-PLAN.md "Aster DelAgent struct — mainnet verification"): the
+ * public Aster V3 docs (asterdex/api-docs, futures api v3 + testnet, checked 2026-10-02)
+ * document no agent-delete endpoint or DelAgent struct, and HypurrQuant_FE has no
+ * revoke method. This field set mirrors the ApproveAgent terminal fields (AgentAddress,
+ * AsterChain, User, Nonce) without the permission booleans. It is only reachable on
+ * mainnet (assertAgentApproveSupported refuses Aster agent management on testnet), and
+ * revoke treats any non-confirming venue response as APPROVE_FAILED (assertAsterAgentDeleted),
+ * so a wrong struct fails loudly instead of reporting a false revoke.
  */
 export function buildDelAgentTypedData(params) {
     const delTypes = [
@@ -112,7 +117,7 @@ export function buildDelAgentTypedData(params) {
     ];
     const message = {
         AgentAddress: params.agentAddress,
-        AsterChain: params.asterChain ?? "Mainnet",
+        AsterChain: params.asterChain,
         User: params.user,
         Nonce: String(params.nonceMicros),
     };
@@ -190,7 +195,7 @@ export function buildApproveBuilderTypedData(params) {
     if (params.builderName !== undefined) {
         message["BuilderName"] = params.builderName;
     }
-    message["AsterChain"] = params.asterChain ?? "Mainnet";
+    message["AsterChain"] = params.asterChain;
     message["User"] = params.user;
     message["Nonce"] = String(params.nonceMicros);
     return {
@@ -200,3 +205,112 @@ export function buildApproveBuilderTypedData(params) {
         message,
     };
 }
+/**
+ * EIP-712 payload for `DELETE /fapi/v3/builder` (revoke a builder approval).
+ * Source: asterdex/api-docs demo/aster-code.py `delBuilder` — main-wallet signed,
+ * primaryType "DelBuilder", fields = the request params with the first letter
+ * upper-cased in insertion order: Builder, AsterChain, User, Nonce (Domain A).
+ */
+export function buildDelBuilderTypedData(params) {
+    return {
+        domain: ASTER_DOMAIN_A,
+        types: {
+            DelBuilder: [
+                { name: "Builder", type: "string" },
+                { name: "AsterChain", type: "string" },
+                { name: "User", type: "string" },
+                { name: "Nonce", type: "uint256" },
+            ],
+        },
+        primaryType: "DelBuilder",
+        message: { Builder: params.builder, AsterChain: params.asterChain, User: params.user, Nonce: String(params.nonceMicros) },
+    };
+}
+// ── buildRegisterAndApproveAgentTypedData ─────────────────────────────────────
+/** signatureChainId for an EVM `user` on POST /fapi/v3/registerAndApproveAgent (101 = Solana). */
+export const ASTER_REGISTER_AGENT_EVM_CHAIN_ID = 56;
+/**
+ * EIP-712 payload for `POST /fapi/v3/registerAndApproveAgent` (asterdex/api-docs
+ * eeddec8, V3 futures v3 + testnet, added 2026-05-12). Unauthenticated endpoint;
+ * the user's wallet signs the literal (not URL-encoded) parameter string
+ *   user=…&nonce=…&agentName=…&agentAddress=…&expired=…&signatureChainId=…&canSpotTrade=…&canPerpTrade=…&canWithdraw=…&ipWhitelist=…
+ * wrapped as Message{msg} under domain AsterSignTransaction / v1 / chainId =
+ * signatureChainId (56 for EVM) / zero verifyingContract. Unlike approveAgent
+ * this carries no AsterChain field — the host selects the network.
+ */
+export function buildRegisterAndApproveAgentTypedData(params) {
+    if (params.canWithdraw && params.ipWhitelist.trim().length === 0) {
+        throw new PerpError("INVALID_PARAMS", "Aster registerAndApproveAgent requires an IP whitelist when withdraw permission is granted", {
+            remediation: "Pass --ip-whitelist \"<ip> <ip/cidr>\" (space-separated), or drop --can-withdraw",
+        });
+    }
+    for (const [k, v] of [["agentName", params.agentName], ["ipWhitelist", params.ipWhitelist]]) {
+        // The signed msg is a raw k=v&… string — a '&' or '=' inside a value would make it ambiguous.
+        if (/[&=]/.test(v)) {
+            throw new PerpError("INVALID_PARAMS", `Aster registerAndApproveAgent: ${k} must not contain '&' or '='`, {
+                remediation: k === "agentName" ? "Choose an --agent-name without '&' or '='" : "Separate IP whitelist entries with spaces",
+            });
+        }
+    }
+    const entries = [
+        ["user", params.user],
+        ["nonce", String(params.nonceMicros)],
+        ["agentName", params.agentName],
+        ["agentAddress", params.agentAddress],
+        ["expired", String(params.expiredMs)],
+        ["signatureChainId", String(params.signatureChainId)],
+        ["canSpotTrade", String(params.canSpotTrade)],
+        ["canPerpTrade", String(params.canPerpTrade)],
+        ["canWithdraw", String(params.canWithdraw)],
+        ["ipWhitelist", params.ipWhitelist],
+    ];
+    return {
+        domain: {
+            name: "AsterSignTransaction",
+            version: "1",
+            chainId: params.signatureChainId,
+            verifyingContract: "0x0000000000000000000000000000000000000000",
+        },
+        types: ORDER_TYPES,
+        primaryType: "Message",
+        message: { msg: entries.map(([k, v]) => `${k}=${v}`).join("&") },
+        params: entries,
+    };
+}
+// ── buildWithdrawTypedData ────────────────────────────────────────────────────
+/** EIP-712 types of the EVM withdraw signature (field names contain spaces — they are part of the type hash). */
+export const ASTER_WITHDRAW_TYPES = {
+    Action: [
+        { name: "type", type: "string" },
+        { name: "destination", type: "address" },
+        { name: "destination Chain", type: "string" },
+        { name: "token", type: "string" },
+        { name: "amount", type: "string" },
+        { name: "fee", type: "string" },
+        { name: "nonce", type: "uint256" },
+        { name: "aster chain", type: "string" },
+    ],
+};
+/**
+ * Master-signed EVM withdraw signature (`userSignature` of POST /fapi/v3/aster/user-withdraw).
+ * Source: asterdex/api-docs demo/aster-deposit-withdrawal.md "EVM Withdraw Signature" and
+ * asterdex/API-demo futures-v3-demo/58_withdrawEvm.js. Domain name "Aster" (NOT the
+ * "AsterSignTransaction" API-auth domain); `aster chain` is the fixed string "Mainnet".
+ */
+export function buildWithdrawTypedData(p) {
+    return {
+        domain: { name: "Aster", version: "1", chainId: p.chainId, verifyingContract: "0x0000000000000000000000000000000000000000" },
+        types: ASTER_WITHDRAW_TYPES,
+        primaryType: "Action",
+        message: {
+            "type": "Withdraw",
+            "destination": p.receiver,
+            "destination Chain": p.chainName,
+            "token": p.asset,
+            "amount": p.amount,
+            "fee": p.fee,
+            "nonce": p.userNonce,
+            "aster chain": "Mainnet",
+        },
+    };
+}

package/dist/exchanges/aster.d.ts

@@ -19,9 +19,40 @@
  * Base: https://fapi.asterdex.com
  */
 import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
+import type { ResolvedSlippage } from "./slippage.js";
 import type { EvmSigner } from "../signer/interface.js";
 import type { AgentMeta } from "../settings.js";
 import type { AgentSigningStrategy } from "../agent-wallet/signing-strategy.js";
+import { PerpError } from "../errors.js";
+import { type BuilderApproval, type BuilderDecision, type BuilderFeeGate, type BuilderTarget } from "./builder-fee.js";
+import { type AsterFundsChain } from "./venues/aster.js";
+import { type AsterWithdrawLimits, type AsterWithdrawResult } from "./aster-funds.js";
+/**
+ * Definite IOC outcome of a raw Aster order response (perp and spot share the
+ * Binance-compatible shape) — contract in ./ioc-outcome.ts. Final only for a terminal
+ * status (FILLED / EXPIRED / CANCELED) with a reported executedQty, on an IOC (or
+ * MARKET) order; anything else → null (caller measures).
+ */
+export declare function asterIocOutcome(raw: unknown): {
+    filledSize: string;
+    final: true;
+} | null;
+/**
+ * Verdict of a failed POST / PUT /fapi/v3/order that the venue ANSWERED with an HTTP 4xx and a
+ * documented error code: the order was refused — a definite, non-retryable PerpError (never the
+ * retryable EXCHANGE_ERROR, which callers must treat as an unknown write outcome). Live mainnet
+ * 2026-10-05: a reduce-only order without a position → 400 {"code":-2022,"msg":"ReduceOnly Order
+ * is rejected."}. Unchanged: HTTP 5xx, no / undocumented code, and the "status unknown" codes —
+ * those become ORDER_PENDING unless the error was already classified definite (e.g. the venue's
+ * -1000 "Signature check failed" → SIGNATURE_FAILED).
+ */
+export declare function asterOrderRejection(e: PerpError): PerpError;
+/**
+ * An Aster client order id as sent / queried. V3 futures "New Order" `newClientOrderId`: "A unique
+ * id among open orders. Automatically generated if not sent. Can only be string following the
+ * rule: ^[\.A-Z\:/a-z0-9_-]{1,36}$". Anything else → INVALID_PARAMS, nothing sent.
+ */
+export declare function requireAsterClientOrderId(id: string): string;
 type ResolvedSigner = {
     tier: "agent" | "master" | "pk";
     signer: EvmSigner | AgentSigningStrategy;
@@ -30,6 +61,8 @@ type ResolvedSigner = {
     /** EVM address of the owner/master — used as `user` field in Aster requests */
     userAddress: string;
 };
+/** Max 1000-row pages of 7-day commission income read for symbol discovery (20 000 fills). */
+export declare const ASTER_INCOME_MAX_PAGES = 20;
 export declare class AsterAdapter implements ExchangeAdapter {
     readonly name = "aster";
     readonly chain = "bnb";
@@ -46,27 +79,108 @@ export declare class AsterAdapter implements ExchangeAdapter {
     private _marketsCache;
     private _marketsCacheTime;
     private _fundingHoursCache;
+    /** When the venue-wide funding-interval table was last loaded (0 = never). */
+    private _fundingInfoLoadedAt;
+    /** API symbol → price filters; null = listed but PRICE_FILTER / PERCENT_PRICE unreadable. */
+    private _priceFilters;
+    private _priceFiltersLoadedAt;
     private _accountCache;
     private _positionsCache;
     private _ordersCache;
     private static readonly CACHE_TTL;
     private static readonly ACCOUNT_CACHE_TTL;
-    private _nonceCounter;
+    /**
+     * Builder-fee gate (settings builder.aster + confirmed master approveBuilder); null = not
+     * configured. Set by createAster — the adapter never reads settings.
+     */
+    builderFee: BuilderFeeGate | null;
     constructor(privateKey?: string, testnet?: boolean);
     init(): Promise<void>;
     setAgent(meta: AgentMeta, strategy: AgentSigningStrategy): void;
     setMasterSigner(signer: EvmSigner): void;
     setPkSigner(signer: EvmSigner): void;
     setNoAgent(noAgent: boolean): void;
+    /** Builder decision for the next perp order (cached approval read; never throws). */
+    builderDecision(): Promise<BuilderDecision>;
+    /** `builder` + `feeRate` (decimal) order params, or none (not configured / not approved). */
+    private _builderParams;
+    /** Owner (`user`) address of the active signer — the account a builder approval belongs to. */
+    get userAddress(): string;
+    /**
+     * Builder approvals of this account: GET /fapi/v3/builder (asterdex/api-docs demo
+     * `getBuilders`, signed by the API wallet). The response shape is not documented, so
+     * anything but a list of rows carrying an address + maxFeeRate is "unknown" (never guessed).
+     */
+    builderApprovalOf(target: BuilderTarget): Promise<BuilderApproval>;
     get isReadOnly(): boolean;
     get activeSignerTier(): "agent" | "master" | "pk" | null;
+    /**
+     * Aster spot REST host. Spot shares the perp EIP-712 Domain B signing
+     * (chainId 1666 mainnet / 714 testnet) and the per-agent nonce space.
+     * Hosts per the official spot V3 docs (mainnet + testnet variants).
+     */
+    get spotBaseUrl(): string;
+    /**
+     * Signed request against an arbitrary Aster host with the active signer.
+     * POST is single-shot; GET/DELETE use the same 429 retry loop as perp.
+     */
+    signedRequest(host: string, method: "GET" | "POST" | "DELETE", path: string, params: Record<string, string | number | boolean>): Promise<unknown>;
+    /**
+     * Agent meta of the active signer, or null when the active signer is not an
+     * agent. Throws exactly like signed calls when no signer is usable.
+     */
+    activeAgentMeta(): AgentMeta | null;
     /** CLI symbol → Aster API symbol (ETH → ETHUSDT) */
     private _toApi;
     /** Aster API symbol → CLI symbol (ETHUSDT → ETH) */
     private _fromApi;
-    /** Get funding interval for a symbol (lazy bootstrap). */
+    /**
+     * Get funding interval for a symbol.
+     *
+     * Source of truth is `GET /fapi/v3/fundingInfo` (weight 1), which states
+     * `fundingIntervalHours` per symbol for the whole venue in a single call.
+     * This previously inferred the interval by differencing the last two
+     * `fundingRate` timestamps and bucketing to 1/4/8h — an estimate that is
+     * wrong for a newly listed symbol (fewer than two settlements), across a
+     * schedule change, or whenever a settlement is skipped/delayed, and Aster
+     * really does mix 1h, 4h and 8h symbols. Funding-interval misconfiguration is
+     * exactly what produced the v0.7.23 Aster funding bug, so it is read, not
+     * guessed.
+     */
     getFundingHours(symbol: string): Promise<number | undefined>;
+    /** Populate the funding-interval cache for every symbol in one call. */
+    private _loadFundingInfo;
     getMarkets(): Promise<ExchangeMarketInfo[]>;
+    /** Parse PRICE_FILTER + PERCENT_PRICE for every exchangeInfo symbol into the cache. */
+    private _ingestPriceFilters;
+    /** PRICE_FILTER / PERCENT_PRICE of an API symbol (exchangeInfo, cached CACHE_TTL). */
+    private _symbolPriceFilters;
+    /**
+     * Declared protection-price reference (§13.10 #5): the venue mark price from
+     * GET /fapi/v3/premiumIndex — the same price PERCENT_PRICE is evaluated against.
+     * No runtime substitute (no mid / last fallback): unavailable → PRICE_STALE.
+     */
+    referencePrice(symbol: string): Promise<string>;
+    /**
+     * Reject (never clamp) a price outside PRICE_FILTER min/max or the side's PERCENT_PRICE
+     * bound around `mark` — checked before anything is sent.
+     */
+    private _checkPriceBand;
+    /**
+     * Protection price an IOC market order on `symbol` would be sent with now:
+     * mark ± slippage.bps, aligned toward crossing on PRICE_FILTER.tickSize, validated
+     * against PRICE_FILTER / PERCENT_PRICE. appliedBps = the bound after tick alignment.
+     */
+    computeProtectionPrice(symbol: string, side: "buy" | "sell", slippage: ResolvedSlippage): Promise<{
+        referencePrice: string;
+        protectionPrice: string;
+        appliedBps: number;
+    }>;
+    /** Definite IOC outcome of a raw order response (see asterIocOutcome). */
+    iocOutcomeOf(raw: unknown): {
+        filledSize: string;
+        final: true;
+    } | null;
     getOrderbook(symbol: string): Promise<{
         bids: [string, string][];
         asks: [string, string][];
@@ -79,30 +193,139 @@ export declare class AsterAdapter implements ExchangeAdapter {
     }[]>;
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     getBalance(): Promise<ExchangeBalance>;
+    /**
+     * How much of ONE asset the perp account can transfer out: that asset's row of
+     * GET /fapi/v3/accountWithJoinMargin `assets[]` — `maxWithdrawAmount` ("maximum amount for
+     * transfer out", Aster futures API v3 "Account Information v3"). The account-level
+     * `availableBalance` (getBalance) is margin across ALL collateral assets in multi-asset mode
+     * and is not an amount of any one asset. Read uncached. A missing row / field is an error,
+     * never 0.
+     */
+    getPerpAssetTransferable(asset: string): Promise<number>;
     getPositions(): Promise<ExchangePosition[]>;
+    /**
+     * Drop the in-process open-orders snapshot (after any order write, or before a verifying
+     * re-list). An order write also changes positions and balances, so those snapshots go too.
+     */
+    invalidateOpenOrdersCache(): void;
     getOpenOrders(): Promise<ExchangeOrder[]>;
+    /**
+     * Symbols with account activity: open positions, open orders, and every symbol with a
+     * COMMISSION income row in the last 7 days (the venue's default window). Aster's userTrades /
+     * allOrders both require `symbol`, so this is the per-symbol fan-out set. Income is read in
+     * pages of 1000 (the endpoint max; startTime / endTime are inclusive) walking back from now;
+     * more than ASTER_INCOME_MAX_PAGES pages → EXCHANGE_ERROR, never a partial set. Orders on a
+     * symbol that never filled, is not open and has no position cannot be found (allOrders needs it).
+     */
+    private _tradedApiSymbols;
+    /**
+     * Recent orders across the symbols with account activity (see _tradedApiSymbols), newest first.
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /**
+     * Recent fills. `GET /fapi/v3/userTrades` requires a symbol (asterdex/api-docs V3), so the
+     * symbols come from the open positions plus every symbol with a COMMISSION income row in the
+     * venue's default window (`GET /fapi/v3/income`: "the recent 7-day data" when no time is sent).
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
-    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
-        reduceOnly?: boolean;
+    /**
+     * Per-market leverage / margin mode: every row of GET /fapi/v3/positionRisk ("Position
+     * Information v3", one row per symbol, position or not — docs example:
+     * `"marginType": "isolated"`, `"leverage": "10"`, `"positionAmt": "0.000"`; rows[].marginType
+     * "Margin type: `isolated` or `cross`"). An unreadable row throws — never a default.
+     */
+    getMarketSettings(): Promise<Array<{
+        symbol: string;
+        leverage: number;
+        marginMode: "cross" | "isolated";
+    }>>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts: {
+        reduceOnly: boolean;
+        slippage: ResolvedSlippage;
+        clientOrderId?: string;
     }): Promise<unknown>;
     limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
         reduceOnly?: boolean;
         tif?: string;
+        clientOrderId?: string;
     }): Promise<unknown>;
+    /**
+     * Native modify (PUT /fapi/v3/order, V3 futures docs "Modify Order"): LIMIT orders
+     * only; TIF (incl. GTX) and reduceOnly stay on the order. `size` is the NEW UNFILLED
+     * quantity (§13.10 #10); the venue's `quantity` is the order total, so
+     * quantity = size + executedQty (read just before). A fill landing between the read
+     * and the PUT can only shrink the remainder, never over-size it. A venue rejection
+     * leaves the original order untouched (docs).
+     */
     editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
     cancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    /**
+     * Cancel one order by client order id — V3 futures "Cancel Order" (DELETE /fapi/v3/order):
+     * "Either `orderId` or `origClientOrderId` must be sent."
+     */
+    cancelOrderByClientId(symbol: string, clientOrderId: string): Promise<unknown>;
+    /**
+     * One order's row — V3 futures "Query Order" (GET /fapi/v3/order, symbol + orderId or
+     * origClientOrderId). Docs: CANCELED / EXPIRED orders with no fill older than 7 days "will not
+     * be found". -2013 NO_SUCH_ORDER → ORDER_NOT_FOUND; any other failure throws as is.
+     */
+    queryOrderRow(symbol: string, ref: {
+        kind: "orderId" | "clientOrderId";
+        value: string;
+    }): Promise<Record<string, unknown>>;
+    private _cancelOne;
     cancelAllOrders(symbol?: string): Promise<unknown>;
     setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<unknown>;
+    /**
+     * Trigger order. Type follows the venue trigger rules (V3 docs, "Condition orders"):
+     * STOP*: BUY fires at price >= stopPrice, SELL at <= ; TAKE_PROFIT*: the reverse. So the
+     * type is chosen from the trigger vs the current trigger-source price and the order side
+     * (the side closing a long is SELL): BUY above / SELL below → STOP, otherwise
+     * TAKE_PROFIT. (Always STOP_MARKET made every TP fail with -2021.)
+     * Trigger source: workingType MARK_PRICE compared with the premiumIndex mark (default),
+     * or CONTRACT_PRICE with the last price when triggerType is "last".
+     * size "0" = whole position → closePosition=true (STOP_MARKET / TAKE_PROFIT_MARKET only;
+     * the venue forbids quantity and reduceOnly with it).
+     * `opts.kind` (TP/SL legs): sl → STOP(_MARKET), tp → TAKE_PROFIT(_MARKET) as given, with
+     * no price read; a trigger already crossed is rejected by the venue (-2021).
+     */
     stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
         limitPrice?: string;
         reduceOnly?: boolean;
+        triggerType?: "mark" | "last" | "mid";
+        kind?: "tp" | "sl";
     }): Promise<unknown>;
-    withdraw(amount: string, _destination: string, _opts?: {
+    /** Last traded price (GET /fapi/v3/ticker/price) — the CONTRACT_PRICE trigger source. */
+    private _lastPrice;
+    /** Asset withdrawn by `withdraw`: `requested` (must be in capabilities.withdrawAssets), else withdrawAssets[0]. */
+    private _withdrawAsset;
+    /**
+     * Withdrawable perp balance + fee for the withdraw asset on `chain`
+     * (POST /fapi/v3/aster/user-withdraw-info, signed by the API wallet). Read-only.
+     */
+    withdrawLimits(chain: AsterFundsChain, asset?: string): Promise<AsterWithdrawLimits>;
+    /** Deposit / withdraw history (POST /fapi/v3/aster/deposit-withdraw-history, signed by the API wallet). Read-only. */
+    depositWithdrawHistory(): Promise<unknown>;
+    /**
+     * Withdraw the venue collateral (USDT) from the perp account to the account owner's OWN address
+     * on BNB Chain (default) or Arbitrum. Two signatures (asterdex/api-docs
+     * demo/aster-deposit-withdrawal.md, API-demo futures-v3-demo/58_withdrawEvm.js):
+     *   1. `userSignature` — the master wallet's EIP-712 "Aster" Action over receiver / chain / token /
+     *      amount / fee / nonce, recovered locally and compared to the account owner before sending;
+     *   2. the V3 envelope signed by the API wallet, which must have canWithdraw (and an IP whitelist).
+     * The fee and the maximum come from user-withdraw-info; the identical amount / fee strings go
+     * into the signature and the request. Once the request left, an unreadable result is
+     * ORDER_PENDING (never resubmit).
+     */
+    withdraw(amount: string, destination: string, opts?: {
         assetId?: number;
         routeType?: number;
-    }): Promise<unknown>;
+        chain?: AsterFundsChain;
+        asset?: string;
+    }): Promise<AsterWithdrawResult>;
     /**
      * Resolve the active signer per the three-tier policy.
      *
@@ -110,6 +333,7 @@ export declare class AsterAdapter implements ExchangeAdapter {
      * from production code outside this class.
      */
     _resolveSigner(): ResolvedSigner;
+    /** Monotonic µs nonce per signer, persisted across processes (aster-nonce.ts). */
     private _nextNonce;
     /**
      * Build the canonical signed-request URL per Aster v3 spec.
@@ -138,6 +362,15 @@ export declare class AsterAdapter implements ExchangeAdapter {
      * Sign and POST to a path using EIP-712 Domain B.
      */
     private _signedPostEip712;
+    /**
+     * A perp account WRITE (order / modify / cancel / margin type / leverage). Once the request is
+     * on the wire, a transport failure, an HTTP 5xx or an unreadable 2xx body leaves the outcome
+     * unknown → ORDER_PENDING (never the retryable EXCHANGE_ERROR / EXCHANGE_UNREACHABLE); no
+     * connection at all → not sent. Venue refusals (4xx, error envelopes) pass through unchanged.
+     */
+    private _perpWrite;
+    /** Sign and POST (or PUT) to `host + path` (perp `fapi` or spot `sapi` — same Domain B signing). */
+    private _signedPostTo;
     /**
      * Sign and GET from a path using EIP-712 Domain B.
      *
@@ -162,6 +395,7 @@ export declare class AsterAdapter implements ExchangeAdapter {
      *  Codex v0.12.12 final QA #3: previously MAX_ATTEMPTS = 3 truncated the
      *  documented curve so the 8s backoff was never reachable in practice. */
     private _signedRequestWithRetry;
+    private _signedRequestLoop;
     /**
      * Unified response validator for ALL signed Aster requests.
      *