perp-cli 0.12.17 → 0.14.0

package/dist/exchanges/precision.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Decimal-string precision helpers for order entry (design §10.10).
+ *
+ * All math is done on scaled BigInt to avoid float drift. Rules:
+ * - limit prices that are not on tick are REJECTED (INVALID_TICK), never rounded;
+ * - slippage-bounded protection prices are aligned toward crossing
+ *   (buy → up, sell → down);
+ * - sizes are floored to the step; a result of zero is SIZE_TOO_SMALL.
+ */
+import type { ExchangeAdapter } from "./interface.js";
+/** Number of ticks (integer) for a value exactly on the grid, or null when off-grid. */
+export declare function exactUnits(value: string, step: string): bigint | null;
+/** Value → integer units; throws INVALID_TICK when off-grid. */
+export declare function toUnitsExact(value: string, step: string, what: string): bigint;
+/** Integer units → decimal string on the step grid. */
+export declare function unitsToString(units: bigint, step: string): string;
+/** Floor a size to the step. Throws SIZE_TOO_SMALL if the result is zero. */
+export declare function floorSize(size: string, stepSize: string): string;
+/** Align a slippage-bounded protection price toward crossing: buy → ceil, sell → floor. */
+export declare function alignProtectionPrice(price: string, tickSize: string, side: "buy" | "sell"): string;
+/** Throws INVALID_PARAMS unless `value` is a plain decimal strictly greater than zero. */
+export declare function requirePositive(value: string, what: string): void;
+/** Validate a limit price is positive and on tick; returns it unchanged (normalized). Throws INVALID_TICK. */
+export declare function requireOnTick(price: string, tickSize: string): string;
+/** Exact (a + b) / 2 of two plain decimal strings (no float arithmetic: 0.1 and 0.2 → "0.15"). */
+export declare function midDecimal(a: string, b: string): string;
+/** Exact decimal a − b (plain decimal strings). */
+export declare function subDecimal(a: string, b: string): string;
+/** Exact decimal a × b (plain decimal strings). */
+export declare function mulDecimal(a: string, b: string): string;
+/** mark × (1 ± bps/10000), as a decimal string (not yet tick-aligned). */
+export declare function slippagePrice(mark: string, side: "buy" | "sell", slippageBps: number): string;
+/**
+ * A COMPUTED price (an average, a mid, notional / size) as a plain decimal string without binary
+ * float noise ("2727.2000000000003" → "2727.2"): rounded to the market tick's decimals when
+ * `tickSize` is given, else to 8 significant digits; trailing zeros dropped. A price the venue
+ * reports as a string is passed through unchanged elsewhere — never run through this.
+ * A non-finite value throws (Rule #2: no "0" / "NaN" price).
+ */
+export declare function formatComputedPrice(value: number, tickSize?: string | null): string;
+/** Floor a non-negative measured amount (e.g. a verified fill) onto the lot grid; "0…" when below one lot. */
+export declare function floorToStep(value: number, step: string): string;
+/**
+ * The market's lot step from the venue market info (stepSize, else 10^-sizeDecimals).
+ * Unknown market or unknown lot → throws (Rule #2: never size orders off the typed decimals).
+ */
+export declare function lotStepOf(adapter: ExchangeAdapter, symbol: string): Promise<string>;

package/dist/exchanges/precision.js

@@ -0,0 +1,209 @@
+/**
+ * Decimal-string precision helpers for order entry (design §10.10).
+ *
+ * All math is done on scaled BigInt to avoid float drift. Rules:
+ * - limit prices that are not on tick are REJECTED (INVALID_TICK), never rounded;
+ * - slippage-bounded protection prices are aligned toward crossing
+ *   (buy → up, sell → down);
+ * - sizes are floored to the step; a result of zero is SIZE_TOO_SMALL.
+ */
+import { PerpError } from "../errors.js";
+/**
+ * Strict plain-decimal parse ("123", "-0.5", "1.250"). Hex, exponent
+ * ("1e-8"), Infinity/NaN, empty and whitespace-padded forms are rejected —
+ * never coerced through Number().
+ */
+function parseDecimal(s) {
+    if (!/^-?\d+(\.\d+)?$/.test(s)) {
+        throw new PerpError("INVALID_PARAMS", `Not a plain decimal number: "${s}"`, {
+            remediation: "Use a plain decimal such as 123.45 (no exponent, hex or spaces)",
+        });
+    }
+    const neg = s.startsWith("-");
+    const body = neg ? s.slice(1) : s;
+    const [ip, fp = ""] = body.split(".");
+    const int = BigInt(ip + fp) * (neg ? -1n : 1n);
+    return { int, scale: fp.length };
+}
+function rescale(v, scale) {
+    if (scale < v.scale)
+        throw new Error("rescale: cannot reduce scale");
+    return v.int * 10n ** BigInt(scale - v.scale);
+}
+function format(int, scale) {
+    const neg = int < 0n;
+    const abs = neg ? -int : int;
+    let s = abs.toString().padStart(scale + 1, "0");
+    if (scale > 0)
+        s = `${s.slice(0, s.length - scale)}.${s.slice(s.length - scale)}`.replace(/\.?0+$/, "");
+    return (neg ? "-" : "") + s;
+}
+/** Number of ticks (integer) for a value exactly on the grid, or null when off-grid. */
+export function exactUnits(value, step) {
+    const v = parseDecimal(value);
+    const st = parseDecimal(step);
+    if (st.int <= 0n)
+        throw new PerpError("INVALID_PARAMS", `step must be positive (got ${step})`);
+    const scale = Math.max(v.scale, st.scale);
+    const vi = rescale(v, scale);
+    const si = rescale(st, scale);
+    if (vi % si !== 0n)
+        return null;
+    return vi / si;
+}
+/** Value → integer units; throws INVALID_TICK when off-grid. */
+export function toUnitsExact(value, step, what) {
+    const u = exactUnits(value, step);
+    if (u === null) {
+        throw new PerpError("INVALID_TICK", `${what} ${value} is not a multiple of ${step}`, {
+            remediation: `Use a ${what} that is a multiple of ${step}`,
+        });
+    }
+    return u;
+}
+function alignUnits(value, step, mode) {
+    const v = parseDecimal(value);
+    const st = parseDecimal(step);
+    if (st.int <= 0n)
+        throw new PerpError("INVALID_PARAMS", `step must be positive (got ${step})`);
+    const scale = Math.max(v.scale, st.scale);
+    const vi = rescale(v, scale);
+    const si = rescale(st, scale);
+    let q = vi / si;
+    const r = vi % si;
+    if (r !== 0n) {
+        if (mode === "floor" && vi < 0n)
+            q -= 1n;
+        if (mode === "ceil" && vi > 0n)
+            q += 1n;
+    }
+    return q;
+}
+/** Integer units → decimal string on the step grid. */
+export function unitsToString(units, step) {
+    const st = parseDecimal(step);
+    return format(units * st.int, st.scale);
+}
+/** Floor a size to the step. Throws SIZE_TOO_SMALL if the result is zero. */
+export function floorSize(size, stepSize) {
+    const u = alignUnits(size, stepSize, "floor");
+    if (u <= 0n) {
+        throw new PerpError("SIZE_TOO_SMALL", `Size ${size} is below the minimum step ${stepSize}`, {
+            remediation: `Use a size of at least ${stepSize}`,
+        });
+    }
+    return unitsToString(u, stepSize);
+}
+/** Align a slippage-bounded protection price toward crossing: buy → ceil, sell → floor. */
+export function alignProtectionPrice(price, tickSize, side) {
+    const u = alignUnits(price, tickSize, side === "buy" ? "ceil" : "floor");
+    if (u <= 0n)
+        throw new PerpError("INVALID_PARAMS", `Protection price ${price} aligns to zero`);
+    return unitsToString(u, tickSize);
+}
+/** Throws INVALID_PARAMS unless `value` is a plain decimal strictly greater than zero. */
+export function requirePositive(value, what) {
+    if (parseDecimal(value).int <= 0n) {
+        throw new PerpError("INVALID_PARAMS", `${what} must be positive (got ${value})`);
+    }
+}
+/** Validate a limit price is positive and on tick; returns it unchanged (normalized). Throws INVALID_TICK. */
+export function requireOnTick(price, tickSize) {
+    requirePositive(price, "price");
+    return unitsToString(toUnitsExact(price, tickSize, "price"), tickSize);
+}
+/** Exact (a + b) / 2 of two plain decimal strings (no float arithmetic: 0.1 and 0.2 → "0.15"). */
+export function midDecimal(a, b) {
+    const x = parseDecimal(a);
+    const y = parseDecimal(b);
+    const scale = Math.max(x.scale, y.scale) + 1; // one more digit holds the possible ".5"
+    return format((rescale(x, scale) + rescale(y, scale)) / 2n, scale);
+}
+/** Exact decimal a − b (plain decimal strings). */
+export function subDecimal(a, b) {
+    const x = parseDecimal(a);
+    const y = parseDecimal(b);
+    const scale = Math.max(x.scale, y.scale);
+    return format(rescale(x, scale) - rescale(y, scale), scale);
+}
+/** Exact decimal a × b (plain decimal strings). */
+export function mulDecimal(a, b) {
+    const x = parseDecimal(a);
+    const y = parseDecimal(b);
+    return format(x.int * y.int, x.scale + y.scale);
+}
+/** mark × (1 ± bps/10000), as a decimal string (not yet tick-aligned). */
+export function slippagePrice(mark, side, slippageBps) {
+    const m = Number(mark);
+    if (!Number.isFinite(m) || m <= 0)
+        throw new PerpError("PRICE_STALE", `Invalid mark price "${mark}"`);
+    const f = side === "buy" ? 1 + slippageBps / 10_000 : 1 - slippageBps / 10_000;
+    if (f <= 0)
+        throw new PerpError("INVALID_PARAMS", `slippageBps ${slippageBps} is too large for a sell`);
+    return (m * f).toFixed(12);
+}
+/** Significant digits kept for a computed price when the market tick is not at hand. */
+const COMPUTED_PRICE_SIG_DIGITS = 8;
+/**
+ * A COMPUTED price (an average, a mid, notional / size) as a plain decimal string without binary
+ * float noise ("2727.2000000000003" → "2727.2"): rounded to the market tick's decimals when
+ * `tickSize` is given, else to 8 significant digits; trailing zeros dropped. A price the venue
+ * reports as a string is passed through unchanged elsewhere — never run through this.
+ * A non-finite value throws (Rule #2: no "0" / "NaN" price).
+ */
+export function formatComputedPrice(value, tickSize = null) {
+    if (!Number.isFinite(value)) {
+        throw new PerpError("EXCHANGE_ERROR", `computed price is not a finite number (${value})`);
+    }
+    const abs = Math.abs(value);
+    const decimals = tickSize !== null
+        ? parseDecimal(tickSize).scale
+        : abs === 0 ? 0 : Math.min(20, Math.max(0, COMPUTED_PRICE_SIG_DIGITS - 1 - Math.floor(Math.log10(abs))));
+    const fixed = value.toFixed(decimals);
+    return fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+}
+/** Floor a non-negative measured amount (e.g. a verified fill) onto the lot grid; "0…" when below one lot. */
+export function floorToStep(value, step) {
+    const dec = (step.split(".")[1] ?? "").length;
+    const f = 10 ** dec;
+    const plain = (Math.floor(Math.max(0, value) * f + 1e-9) / f).toFixed(dec);
+    return unitsToString(alignUnits(plain, step, "floor"), step);
+}
+/**
+ * The market's lot step from the venue market info (stepSize, else 10^-sizeDecimals).
+ * Unknown market or unknown lot → throws (Rule #2: never size orders off the typed decimals).
+ */
+export async function lotStepOf(adapter, symbol) {
+    // The adapter's own lot step from market metadata it already holds (Lighter: size decimals of
+    // its loaded market list) — no full market-list read per order.
+    const own = adapter.lotStepOf;
+    if (typeof own === "function")
+        return own.call(adapter, symbol);
+    const strip = (s) => s.toUpperCase().replace(/-PERP$/, "");
+    // The adapter's own symbol resolution when it has one (HL "GOOGL" → "km:GOOGL" on a HIP-3 dex).
+    const resolve = adapter.resolveSymbol;
+    const wanted = new Set([strip(symbol), ...(typeof resolve === "function" ? [strip(resolve.call(adapter, symbol))] : [])]);
+    const markets = await adapter.getMarkets();
+    let m = markets.find(x => wanted.has(strip(x.symbol)));
+    if (m === undefined) {
+        // HIP-3: the dex adapter lists "xyz:XYZ100" while callers (and its asset map) also use the
+        // bare "XYZ100". Only an unambiguous dex-prefixed match counts.
+        const bare = markets.filter(x => x.symbol.includes(":") && wanted.has(strip(x.symbol.split(":").pop())));
+        if (bare.length > 1) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `${adapter.name}: ${symbol} is ambiguous (${bare.map(x => x.symbol).join(", ")}) — lot step unknown`, { exchange: adapter.name });
+        }
+        m = bare[0];
+    }
+    if (m === undefined) {
+        throw new PerpError("SYMBOL_NOT_FOUND", `${adapter.name}: market ${symbol} not found — lot step unknown`, { exchange: adapter.name });
+    }
+    if (m.stepSize !== null)
+        return m.stepSize;
+    if (m.sizeDecimals !== null && Number.isInteger(m.sizeDecimals) && m.sizeDecimals >= 0) {
+        return m.sizeDecimals === 0 ? "1" : `0.${"0".repeat(m.sizeDecimals - 1)}1`;
+    }
+    throw new PerpError("EXCHANGE_ERROR", `${adapter.name} ${symbol}: the venue market info has no lot step (stepSize / sizeDecimals) — cannot size the order to the lot`, {
+        exchange: adapter.name,
+        remediation: `Check the market: perp -e ${adapter.name} market info ${symbol}`,
+    });
+}

package/dist/exchanges/qfex/adapter.d.ts

@@ -0,0 +1,341 @@
+/**
+ * QFEX adapter — native TradingV2 + legacy ExchangeAdapter shim
+ * (design §14.3–§14.6 as amended by §14.12; §10.7, §10.10, §13).
+ *
+ * Signer: imported HMAC API key only (QfexAgentMeta → ~/.perp/qfex-agents/<publicKey>.json).
+ * Orders go over the Trade WebSocket (ws-transport.ts); account reads, leverage and transfers
+ * over REST; deposit address / withdraw over the banker host.
+ *
+ * Order entry:
+ *   - market orders: IOC LIMIT at alignProtectionPrice(slippagePrice(mark, side, bps), tick,
+ *     side) — the venue's native MARKET has no user bound. The reference is the MDS
+ *     market_stats mark of THAT symbol, refused (PRICE_STALE) when its own `time` is older than
+ *     QFEX_MARK_MAX_AGE_MS; nothing else is substituted.
+ *   - limit: GTC | IOC | FOK as LIMIT; ALO as order_type ALO + GTC.
+ *   - precision, bands, status, allowed order types / TIFs: /refdata only. Off-tick prices and
+ *     out-of-band prices are refused, never rounded or clamped; sizes are floored to the lot.
+ *   - client order ids are generated (UUID); a GTC / ALO order is returned as acknowledged
+ *     (pending) after its ACK — "open" comes only from getOrderStatus (a get_user_orders row).
+ *     An ALO order the venue cancels right after the ACK (it would cross) is ORDER_REJECTED
+ *     { reason: "postOnlyWouldCross" }.
+ *   - IOC / FOK / market: final only on a venue terminal frame; a terminal frame with zero
+ *     fill is ORDER_REJECTED { reason: "iocNoFill" }; no terminal frame in time → pending.
+ *
+ *   - reduce-only (close / reduce / flatten, reduce-only IOC limits): `reduce_only: true`, and —
+ *     because the venue accepts a reduce-only order larger than the position (Q2, signing.ts) —
+ *     the adapter's own rule before every send (requireReducible) and an echo check after it.
+ *
+ * Refused for now (uniform CAPABILITY_UNSUPPORTED, see signing.ts constants):
+ *   - a RESTING reduce-only order (GTC / ALO; capability reduceOnlyTif, and so `trade scale-tp`)
+ *     until QFEX_RESTING_REDUCE_ONLY_VERIFIED;
+ *   - unattended automation — bots, plans, TWAP, DCA, grid, funding-arb, trailing stop,
+ *     background jobs (automationGate) — until QFEX_AUTOMATION_VERIFIED;
+ *   - stop-limit and stops that open (the venue offers neither); reduce-only stop-MARKET orders
+ *     (TAKE_PROFIT / STOP_LOSS, Q21 passed — placeStop) are placed;
+ *   - amend of a reduce-only order (a plain LIMIT / ALO is amended — Q5 passed);
+ *   - attached TP/SL (Q7);
+ *   - markets not quoted in USD (sizing / risk / notional code assumes USD);
+ *   - user-supplied client order ids (not unique on the venue).
+ *
+ * Funding: unverified (Q4) → getVenueMarkets()/getMarkets() report fundingRate null.
+ */
+import { PerpError } from "../../errors.js";
+import type { WithdrawGate } from "../../settings.js";
+import { type BuilderFeeGate } from "../builder-fee.js";
+import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade } from "../interface.js";
+import type { IocOutcome } from "../ioc-outcome.js";
+import type { ResolvedSlippage } from "../slippage.js";
+import type { TradingV2 } from "../trading-v2.js";
+import type { VenueCreateContext, VenueDefinition } from "../venue.js";
+import type { AmendRequest, CancelResult, LeverageResult, Network, OrderRef, OrderRequest, OrderResult, VenueMarket } from "../venue-types.js";
+import { type QfexReduceOnlyWire } from "./signing.js";
+import { qfexPendingRemediation, type QfexOrderResponse } from "./ws-transport.js";
+/** A mark price entry older than this (its own venue `time`) is not used as an order reference. */
+export declare const QFEX_MARK_MAX_AGE_MS = 10000;
+/** Client order id sent to the venue: a fresh UUID (the format the venue itself generates). */
+export declare function qfexClientOrderId(): string;
+/**
+ * JSON number → plain decimal string (never exponent notation). The venue sends decimals as
+ * JSON numbers, i.e. binary doubles, and some carry the venue's own float noise (live
+ * 2026-10-05 `/user/positions` average_price 4142.099999999999 for a 4142.1 entry). A double
+ * represents every decimal of up to 15 significant digits exactly-once (IEEE 754 binary64
+ * DBL_DIG = 15), so the value is read at 15 significant digits: noise in the 16th/17th digit
+ * is dropped and no real venue decimal is altered. Fields with a known grid (order price /
+ * quantity) are quantized to the instrument tick / lot instead (fromWireNumber).
+ */
+export declare function plainNumber(n: unknown, what: string): string;
+export interface QfexAddOrderWire {
+    symbol: string;
+    side: "BUY" | "SELL";
+    order_type: "LIMIT" | "ALO";
+    order_time_in_force: "GTC" | "IOC" | "FOK";
+    quantity: number;
+    price: number;
+    client_order_id: string;
+    reduce_only?: boolean | number;
+    [k: string]: unknown;
+}
+/**
+ * The frame of a reduce-only order that fails the echo check, or null when the order is confirmed
+ * as reduce-only. The rule, from production frames (2026-10-05, signing.ts Q2):
+ *  - the ACK and every other NON-FILL status frame (CANCELLED, IOC_CANCELLED, MODIFIED, a
+ *    post-ACK rejection, …) describes the ORDER and must carry `reduce_only: true`;
+ *  - a fill-carrying frame (status FILLED) describes the TRADE and is NOT judged: the venue sends
+ *    `reduce_only: false` on it for an order whose ACK and CANCELLED frames both carry `true`;
+ *  - an order with no non-fill frame at all has nothing that confirms the flag, so its frames are
+ *    judged as they are (a missing confirmation is never read as confirmed).
+ */
+export declare function reduceOnlyUnconfirmedFrame(responses: readonly QfexOrderResponse[]): QfexOrderResponse | null;
+/**
+ * add_order params. `take_profit` / `stop_loss` are never sent (no attached TP/SL). `reduce_only`
+ * is sent only for a reduce-only order, in the verified wire format — with the format unset a
+ * reduce-only order is refused here.
+ */
+export declare function buildAddOrderParams(o: {
+    venueSymbol: string;
+    side: "buy" | "sell";
+    orderType: "LIMIT" | "ALO";
+    tif: "GTC" | "IOC" | "FOK";
+    quantity: string;
+    price: string;
+    clientOrderId: string;
+    reduceOnly: boolean;
+}, reduceOnlyWire: QfexReduceOnlyWire | null): QfexAddOrderWire;
+export declare class QfexAdapter implements ExchangeAdapter, TradingV2 {
+    readonly name: "qfex";
+    readonly aliases: readonly ["qf"];
+    readonly venue: VenueDefinition;
+    readonly network: Network;
+    private readonly caps;
+    private readonly client;
+    private readonly meta;
+    private readonly credentials;
+    private instruments;
+    /**
+     * Builder-code gate (settings builder.qfex; no approval step); null = not configured. Set by
+     * the venue definition's create — the adapter never reads settings.
+     */
+    builderFee: BuilderFeeGate | null;
+    /**
+     * settings.withdraw.qfex, set by the venue definition's create; null = not configured →
+     * withdraw() refuses. Enforced inside withdraw() so no caller can skip it.
+     */
+    withdrawGate: WithdrawGate | null;
+    constructor(def: VenueDefinition, ctx: VenueCreateContext);
+    /** The account UUID every request of this adapter acts as. */
+    get accountId(): string;
+    private requireMeta;
+    /** The builder decision for the connection (the code rides on the session's auth, never per order). */
+    private builderDecision;
+    private session;
+    private instrumentMap;
+    private instrumentOf;
+    /** Refuse a market perp-cli must not send orders to, and an order type / TIF the symbol does not list. */
+    private requireOrderable;
+    /** Mark of ONE symbol from a single-symbol MDS subscription; PRICE_STALE when absent or older than QFEX_MARK_MAX_AGE_MS. */
+    private referenceMark;
+    private checkBand;
+    /**
+     * `minimum: "deferred"` — a reduce-only order: its minimum is checked in requireReducible, once
+     * the position is known (a full close of a sub-minimum residual is not refused here).
+     */
+    private checkSize;
+    /** The uniform refusal of every reduce-only order while the wire format is unset; null now that Q2 set it. */
+    reduceOnlyGate(): PerpError | null;
+    /**
+     * The uniform refusal of every UNATTENDED flow (bots, plans, TWAP, DCA, grid, funding-arb,
+     * trailing stop, background jobs) while stops are refused: an automated strategy would have no
+     * protective exit on the venue. Manual commands never ask. Null once QFEX_AUTOMATION_VERIFIED.
+     */
+    automationGate(): PerpError | null;
+    /**
+     * The uniform refusal of every stop order while Q21 is unset — and so of `--tp/--sl` and
+     * `trade tpsl`, whose legs are stops. Callers ask BEFORE an entry is sent (stopOrderGateOf).
+     * Null now that Q21 passed (QFEX_STOP_CLIENT_ID_ECHO).
+     */
+    stopOrderGate(): PerpError | null;
+    /**
+     * One reduce-only stop-market order (add_order with order_type TAKE_PROFIT / STOP_LOSS).
+     * Docs stop_add_order: "The direction given must be the eventual direction of the triggered
+     * order", `price` = "Price for when the order is triggered", quantity "Must respect lot size
+     * but not min/max limits", order_time_in_force "Required for legacy reasons, the value will
+     * not be read", and "TAKE_PROFIT and STOP_LOSS orders cannot exceed your current position,
+     * attempting to do this could cause your order to be rejected or other stop orders to be
+     * cancelled". So, before sending (every refusal definite, nothing sent):
+     *   - a non-zero position, the order side opposite to it;
+     *   - size + Σ quantity of the other open stops of the SAME type on the symbol ≤ |position|
+     *     (never makes the venue cancel another stop);
+     *   - kind given (TP/SL legs) or, for a plain stop, from the trigger vs the MDS mark price
+     *     (closing a long: below mark = STOP_LOSS, above = TAKE_PROFIT; a short: the mirror).
+     * After the send: the ACK must carry our client id and reduce_only true (production 2026-10-12);
+     * the row is then read back from get_user_orders (final "open" only with that row). The venue's
+     * repeating `stop_order_response` frames are a heartbeat and never read as state.
+     */
+    private placeStop;
+    /** A TP / SL leg (separateOrders: legacy-trading-v2 placeTpSlLeg dispatches here). Stop-market only. */
+    placeTpSlLeg(leg: {
+        symbol: string;
+        closeSide: "buy" | "sell";
+        size: string;
+        trigger: string;
+        kind: "tp" | "sl";
+        limitPrice: string | null;
+    }): Promise<OrderResult>;
+    /**
+     * Orders left on symbols where the account holds NO position: resting reduce-only LIMIT / ALO
+     * orders and TAKE_PROFIT / STOP_LOSS stops. Production 2026-10-12 (Q2): the venue does NOT
+     * cancel a resting reduce-only order when the position closes; whether one the market reaches
+     * while flat would open a position is unproven. `symbol` null = every symbol.
+     */
+    orphanedReduceOnlyOrders(symbol: string | null): Promise<Array<{
+        symbol: string;
+        orderId: string;
+        type: string;
+        side: string;
+        price: string;
+        quantity: string;
+    }>>;
+    /**
+     * The rule before EVERY reduce-only send. The venue accepts a reduce-only order larger than
+     * the position (Q2, signing.ts), so the size is enforced here, on live reads:
+     *   (a) GET /user/positions has a non-zero position on the symbol — none → POSITION_NOT_FOUND;
+     *   (b) the order side is opposite to it (long → sell, short → buy);
+     *   (c) size ≤ |position| − Σ quantity_remaining of ALL this account's other open LIMIT / ALO
+     *       orders on that symbol and side (get_user_orders rows) — a plain SELL consumes a long
+     *       exactly like a reduce-only one, so both are counted;
+     *   (d) size ≥ min_quantity, unless the order closes the whole (floored) position.
+     * A same-side open order whose row does not report `reduce_only` as a boolean is not in the
+     * verified row format (Q2) → refused, with the cancel command. Stop rows (TAKE_PROFIT / STOP_LOSS) are not counted: the
+     * venue's stops "act only to decrease position at the time of execution" (docs
+     * /qfex/order-types); they are reported as an execution note instead.
+     * Every refusal is definite — nothing was sent. The position is floored to the lot.
+     * Returns the execution notes of the check.
+     */
+    private requireReducible;
+    /**
+     * A reduce-only order the venue did not confirm as reduce-only (`reduce_only` false or absent
+     * on an order frame — reduceOnlyUnconfirmedFrame — or on a read-back row of THIS order). The order may be live as a normal order, so the outcome is
+     * unknown (ORDER_PENDING, design §14.12 #4e: never re-sent). It is NOT cancelled here: a cancel
+     * is a second mutating command with its own unknown outcome and cannot undo a fill.
+     */
+    private reduceOnlyEchoError;
+    getVenueMarkets(): Promise<VenueMarket[]>;
+    placeOrder(input: OrderRequest): Promise<OrderResult>;
+    /** Map a correlated add_order outcome to an OrderResult — fills from venue frames only, decimal math. */
+    private orderResultOf;
+    /**
+     * Final filled size of an order placed through the legacy shim — non-null ONLY when a venue
+     * terminal frame was received (design §14.12 #3). A pending result is never an outcome.
+     */
+    iocOutcomeOf(raw: unknown): IocOutcome | null;
+    amendOrder(req: AmendRequest): Promise<OrderResult>;
+    /** The open-order row for a ref; a client id shared by several open orders is ambiguous and refused. */
+    private pick;
+    private openOrderResult;
+    private historicResult;
+    /** Open orders first (get_user_orders), then the historic store; null when neither has it. `source` says which one answered. */
+    private findOrder;
+    getOrderStatus(symbol: string, ref: OrderRef): Promise<OrderResult>;
+    cancelByRef(symbol: string, ref: OrderRef): Promise<CancelResult>;
+    cancelAllV2(symbol: string | null): Promise<CancelResult>;
+    /**
+     * How an order that disappeared from the open orders ended, from its /user/historic-orders row
+     * (Q6: the row may lag): "cancelled" / "filled" when the row proves it, else "not indexed" /
+     * the unproven status after HISTORY_SETTLE_TRIES reads HISTORY_SETTLE_DELAY_MS apart.
+     */
+    /** After an unknown stop-cancel outcome: "cancelled"/"filled" only when the stop is no longer listed open
+     *  AND its historic-orders row settles it; otherwise a reason string (the cancel stays pending). */
+    private settleUnknownStopCancel;
+    private settledByHistory;
+    applyLeverage(symbol: string, leverage: number, marginMode: "cross" | "isolated" | null): Promise<LeverageResult>;
+    getMarkets(): Promise<ExchangeMarketInfo[]>;
+    getOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getRecentTrades(): Promise<ExchangeTrade[]>;
+    /** Hourly funding windows (GET /funding/{symbol}, intervalMinutes 60). `limit` = hours back (default 24). */
+    getFundingHistory(symbol: string, limit?: number): Promise<{
+        time: number;
+        rate: string;
+        price: string | null;
+    }[]>;
+    getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
+    private userPositions;
+    /** Equity is the venue's own figure (GET /user/subaccounts/equity) — never recomputed from balance fields. */
+    getBalance(): Promise<ExchangeBalance>;
+    /**
+     * `position` is a signed quantity: positive = long, negative = short (the response has no
+     * side field; Q10). requireReducible reads the same sign for reduce-only orders. The mark
+     * comes from the MDS snapshot; the venue reports no liquidation price.
+     */
+    getPositions(): Promise<ExchangePosition[]>;
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /** `order_timestamp` is unix seconds with a fraction (the same unit as order_response.update_time). */
+    getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    getFundingPayments(): Promise<ExchangeFundingPayment[]>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts: {
+        reduceOnly: boolean;
+        slippage: ResolvedSlippage;
+    }): Promise<OrderResult>;
+    limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
+        reduceOnly?: boolean;
+        tif?: string;
+    }): Promise<OrderResult>;
+    editOrder(symbol: string, orderId: string, price: string, size: string): Promise<OrderResult>;
+    cancelOrder(symbol: string, orderId: string): Promise<CancelResult>;
+    cancelAllOrders(symbol?: string): Promise<CancelResult>;
+    setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<LeverageResult>;
+    stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
+        limitPrice?: string;
+        reduceOnly?: boolean;
+        triggerType?: "mark" | "last" | "mid";
+    }): Promise<OrderResult>;
+    /**
+     * Deposit address for USDC on Arbitrum One (banker GET /address). The address is returned
+     * only when the venue confirms exactly that network and asset — anything else is refused,
+     * because funds sent on another network / asset are lost.
+     */
+    depositAddress(): Promise<{
+        address: string;
+        network: string;
+        asset: string;
+    }>;
+    /**
+     * Withdraw USDC to an Arbitrum One address (banker POST /withdraw — NOT idempotent).
+     * Authority is the API key alone, so the local withdraw gate (settings.withdraw.qfex:
+     * allowlist, maxPerTx, maxPerDay) is enforced HERE; absent → refused. The venue may still
+     * refuse: QFEX documents that withdrawals need 2FA on the web app.
+     * No balance pre-check: the venue's Withdrawable Balance is not exposed by the API and
+     * `available_balance` is a different quantity — the venue's own 400 is the answer.
+     */
+    withdraw(amount: string, destination: string, opts?: {
+        assetId?: number;
+        routeType?: number;
+    }): Promise<{
+        accepted: true;
+        amount: string;
+        address: string;
+        network: string;
+        asset: "USDC";
+        fee: null;
+        note: string;
+    }>;
+    /** The user's accounts (GET /user/subaccounts/balance): id, primary flag, available balance. */
+    listAccounts(): Promise<Array<{
+        accountId: string;
+        isPrimary: boolean;
+        available: string;
+    }>>;
+    /**
+     * Move USDC between two of the user's accounts (POST /user/transfer → 204). Idempotency and
+     * the needed permission are unverified (Q16): an unknown outcome is ORDER_PENDING, never re-sent.
+     */
+    transferBetweenAccounts(amount: string, fromAccountId: string, toAccountId: string): Promise<{
+        amount: string;
+        from: string;
+        to: string;
+    }>;
+}
+export { qfexPendingRemediation };