perp-cli 0.12.17 → 0.14.0

package/dist/event-stream.js

@@ -16,6 +16,8 @@ export async function startEventStream(adapter, opts) {
     let prevOrders = new Map();
     let prevBalance = null;
     let cycle = 0;
+    // One-time notice per stream (one adapter = one venue) when the venue reports no liquidation price.
+    let warnedNoLiquidationPrice = false;
     const poll = async () => {
         cycle++;
         const ts = new Date().toISOString();
@@ -66,9 +68,33 @@ export async function startEventStream(adapter, opts) {
             }
             // ── Liquidation warnings ──
             for (const p of positions) {
+                // No liquidation price from the venue → no distance to measure. Checked
+                // before Number() because Number(null) === 0 would look like a real price.
+                if (p.liquidationPrice === null) {
+                    if (!warnedNoLiquidationPrice) {
+                        warnedNoLiquidationPrice = true;
+                        console.warn(`[event-stream] ${adapter.name} does not report liquidation prices (first: ${p.symbol}) — liquidation warnings are unavailable for this venue`);
+                    }
+                    continue;
+                }
                 const mark = Number(p.markPrice);
                 const liq = Number(p.liquidationPrice);
-                if (mark > 0 && liq > 0 && p.liquidationPrice !== "N/A") {
+                // Rule #2: a NaN mark or liq would silently fail the `> 0` checks
+                // (NaN comparisons are always false), suppressing the
+                // critical-distance liquidation_warning the user depends on.
+                // Surface the corruption explicitly so the stream layer doesn't
+                // hide a failed alert.
+                //
+                // Strict policy (qa/2026-05-16): an empty-string markPrice or
+                // liquidationPrice is also corruption — `Number("") === 0` would
+                // pass the `Number.isFinite` check, then `mark > 0` would be
+                // false, silently skipping the alert without surfacing the
+                // payload break. Add an explicit "" check to the rejection bucket.
+                if (p.markPrice === "" || p.liquidationPrice === "" || !Number.isFinite(mark) || !Number.isFinite(liq)) {
+                    console.warn(`[event-stream] non-finite mark/liquidation for ${p.symbol} on ${adapter.name} (mark=${p.markPrice}, liq=${p.liquidationPrice}) — skipping liquidation distance check`);
+                    continue;
+                }
+                if (mark > 0 && liq > 0) {
                     const distancePct = Math.abs(mark - liq) / mark * 100;
                     if (distancePct < 3) {
                         emit({
@@ -121,22 +147,42 @@ export async function startEventStream(adapter, opts) {
             prevOrders = currentOrders;
             // ── Balance updates ──
             if (prevBalance) {
-                const equityDelta = Math.abs(Number(balance.equity) - Number(prevBalance.equity));
-                const availDelta = Math.abs(Number(balance.available) - Number(prevBalance.available));
-                if (equityDelta > 0.01 || availDelta > 0.01) {
-                    emit({
-                        type: "balance_update",
-                        exchange: adapter.name,
-                        timestamp: ts,
-                        data: {
-                            equity: balance.equity,
-                            available: balance.available,
-                            marginUsed: balance.marginUsed,
-                            unrealizedPnl: balance.unrealizedPnl,
-                            prevEquity: prevBalance.equity,
-                            prevAvailable: prevBalance.available,
-                        },
-                    });
+                const equityNow = Number(balance.equity);
+                const equityPrev = Number(prevBalance.equity);
+                const availNow = Number(balance.available);
+                const availPrev = Number(prevBalance.available);
+                // Rule #2: a NaN delta would silently fail the `> 0.01` threshold,
+                // suppressing balance_update events. Surface the corruption.
+                //
+                // Strict policy (qa/2026-05-16): "" coerces to 0 via Number(""),
+                // so `Math.abs(0 - prev)` could pass the `> 0.01` check and emit
+                // a misleading balance_update with `data.equity = ""`. Reject ""
+                // upfront so the corruption is visible, not laundered into a
+                // synthetic delta event.
+                const empties = balance.equity === "" || prevBalance.equity === "" ||
+                    balance.available === "" || prevBalance.available === "";
+                if (empties || !Number.isFinite(equityNow) || !Number.isFinite(equityPrev) ||
+                    !Number.isFinite(availNow) || !Number.isFinite(availPrev)) {
+                    console.warn(`[event-stream] non-finite balance values for ${adapter.name} (equity=${balance.equity}/${prevBalance.equity}, available=${balance.available}/${prevBalance.available}) — skipping balance_update emit`);
+                }
+                else {
+                    const equityDelta = Math.abs(equityNow - equityPrev);
+                    const availDelta = Math.abs(availNow - availPrev);
+                    if (equityDelta > 0.01 || availDelta > 0.01) {
+                        emit({
+                            type: "balance_update",
+                            exchange: adapter.name,
+                            timestamp: ts,
+                            data: {
+                                equity: balance.equity,
+                                available: balance.available,
+                                marginUsed: balance.marginUsed,
+                                unrealizedPnl: balance.unrealizedPnl,
+                                prevEquity: prevBalance.equity,
+                                prevAvailable: prevBalance.available,
+                            },
+                        });
+                    }
                 }
             }
             prevBalance = balance;
@@ -169,8 +215,18 @@ export async function startEventStream(adapter, opts) {
     // Polling loop
     while (!opts.signal?.aborted) {
         await new Promise((resolve) => {
-            const timer = setTimeout(resolve, intervalMs);
-            opts.signal?.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+            const signal = opts.signal;
+            let timer;
+            const onAbort = () => { clearTimeout(timer); resolve(); };
+            // When the timer wins the race, remove the abort listener so it does not
+            // accumulate on the (long-lived) signal across polling iterations.
+            // When abort wins, { once: true } removes it. Either way the signal is
+            // left with zero listeners from this iteration — no MaxListeners leak.
+            timer = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, intervalMs);
+            signal?.addEventListener("abort", onAbort, { once: true });
         });
         if (opts.signal?.aborted)
             break;

package/dist/evm-master-tx.d.ts

@@ -0,0 +1,59 @@
+/**
+ * On-chain EVM transactions sent by the master wallet (Aster vault deposit, Ondo funding
+ * transfer, Relay bridge deposits).
+ *
+ * One path for all of them: simulate (eth_estimateGas from the sender) → gas balance check →
+ * sign through a transaction signer (the digest is derived from the unsigned tx inside the
+ * signer — no raw-digest API) → verify the recovered sender → broadcast → wait for the receipt.
+ *
+ * Unknown outcomes are never reported as failures: once the signed transaction left this
+ * process, a lost broadcast response, an RPC error while waiting, or a receipt timeout is
+ * ORDER_PENDING carrying the transaction hash ("do NOT resend").
+ */
+import { Interface, JsonRpcProvider, Transaction, type TransactionReceipt } from "ethers";
+import { PerpError } from "./errors.js";
+import type { CliCredentialOpts } from "./config.js";
+import type { VenueId } from "./exchanges/venue-types.js";
+import type { OwsEvmSigner } from "./signer/ows-evm.js";
+/** Signs an unsigned tx (hashing internally) and returns the 65-byte 0x signature. */
+export type TxSigner = (tx: Transaction) => Promise<string>;
+export declare const EVM_RECEIPT_TIMEOUT_MS = 180000;
+export declare const ERC20: Interface;
+export declare const EVM_ADDRESS_RE: RegExp;
+export declare function sameAddress(a: string, b: string): boolean;
+export declare function evmProvider(rpcUrl: string, chainId: number): JsonRpcProvider;
+/** The RPC must serve the pinned chain — a wrong endpoint never receives a signed transaction. */
+export declare function assertRpcChainId(rpc: JsonRpcProvider, rpcUrl: string, chainId: number, venue: string): Promise<void>;
+/** On-chain decimals() — never assumed from a table. */
+export declare function erc20Decimals(rpc: JsonRpcProvider, token: string): Promise<number>;
+export declare function erc20Balance(rpc: JsonRpcProvider, token: string, owner: string): Promise<bigint>;
+export declare function erc20Allowance(rpc: JsonRpcProvider, token: string, owner: string, spender: string): Promise<bigint>;
+export interface MasterTx {
+    /** Venue / provider name for error attribution ("aster", "ondo", "relay"). */
+    venue: string;
+    /** Human chain name for messages ("BNB Chain"). */
+    chainLabel: string;
+    chainId: number;
+    from: string;
+    to: string;
+    data: string;
+    value: bigint;
+    /** What this transaction is, for messages ("USDT approve"). */
+    label: string;
+}
+/** A sent transaction whose result could not be read: unknown outcome carrying the hash. */
+export declare function txOutcomeUnknown(t: MasterTx, txHash: string, why: string): PerpError;
+/**
+ * Simulate, sign, broadcast one master-wallet transaction and return its hash + successful receipt.
+ * Throws before signing when the simulation reverts or gas is short (nothing sent); a reverted
+ * receipt is ACTION_REJECTED (definite); anything unreadable after the broadcast is ORDER_PENDING.
+ */
+export declare function sendMasterTx(rpc: JsonRpcProvider, t: MasterTx, sign: TxSigner): Promise<{
+    txHash: string;
+    receipt: TransactionReceipt;
+}>;
+/**
+ * The OWS master wallet as a transaction signer. On-chain master transactions are signed only by
+ * an OWS wallet (digest derived inside the signer); no master / a raw private key → NO_SIGNER_AVAILABLE.
+ */
+export declare function loadMasterEvmSigner(venue: VenueId, opts: CliCredentialOpts, action: string): Promise<OwsEvmSigner>;

package/dist/evm-master-tx.js

@@ -0,0 +1,154 @@
+/**
+ * On-chain EVM transactions sent by the master wallet (Aster vault deposit, Ondo funding
+ * transfer, Relay bridge deposits).
+ *
+ * One path for all of them: simulate (eth_estimateGas from the sender) → gas balance check →
+ * sign through a transaction signer (the digest is derived from the unsigned tx inside the
+ * signer — no raw-digest API) → verify the recovered sender → broadcast → wait for the receipt.
+ *
+ * Unknown outcomes are never reported as failures: once the signed transaction left this
+ * process, a lost broadcast response, an RPC error while waiting, or a receipt timeout is
+ * ORDER_PENDING carrying the transaction hash ("do NOT resend").
+ */
+import { Interface, JsonRpcProvider, Network as EthersNetwork, Signature, Transaction } from "ethers";
+import { PerpError, isConnectFailure } from "./errors.js";
+export const EVM_RECEIPT_TIMEOUT_MS = 180_000;
+/** Gas-limit headroom over eth_estimateGas. */
+const GAS_HEADROOM_PCT = 20n;
+export const ERC20 = new Interface([
+    "function decimals() view returns (uint8)",
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function transfer(address to, uint256 amount) returns (bool)",
+]);
+export const EVM_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+export function sameAddress(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+export function evmProvider(rpcUrl, chainId) {
+    const net = EthersNetwork.from(chainId);
+    return new JsonRpcProvider(rpcUrl, net, { staticNetwork: net });
+}
+/** The RPC must serve the pinned chain — a wrong endpoint never receives a signed transaction. */
+export async function assertRpcChainId(rpc, rpcUrl, chainId, venue) {
+    const served = BigInt(await rpc.send("eth_chainId", []));
+    if (served !== BigInt(chainId)) {
+        throw new PerpError("EXCHANGE_ERROR", `${venue}: RPC ${rpcUrl} serves chainId ${served}, expected ${chainId} — nothing was sent`, { exchange: venue });
+    }
+}
+/** On-chain decimals() — never assumed from a table. */
+export async function erc20Decimals(rpc, token) {
+    const raw = await rpc.call({ to: token, data: ERC20.encodeFunctionData("decimals", []) });
+    return Number(ERC20.decodeFunctionResult("decimals", raw)[0]);
+}
+export async function erc20Balance(rpc, token, owner) {
+    const raw = await rpc.call({ to: token, data: ERC20.encodeFunctionData("balanceOf", [owner]) });
+    return ERC20.decodeFunctionResult("balanceOf", raw)[0];
+}
+export async function erc20Allowance(rpc, token, owner, spender) {
+    const raw = await rpc.call({ to: token, data: ERC20.encodeFunctionData("allowance", [owner, spender]) });
+    return ERC20.decodeFunctionResult("allowance", raw)[0];
+}
+/** A sent transaction whose result could not be read: unknown outcome carrying the hash. */
+export function txOutcomeUnknown(t, txHash, why) {
+    return new PerpError("ORDER_PENDING", `${t.venue} ${t.label}: transaction ${txHash} was sent on ${t.chainLabel} but its result is unknown — ${why}`, {
+        exchange: t.venue, txHash, chainId: t.chainId,
+        remediation: `Do NOT resend — the transaction may still confirm. Check ${txHash} on a ${t.chainLabel} explorer, then the balances, before doing anything else`,
+    });
+}
+/**
+ * Simulate, sign, broadcast one master-wallet transaction and return its hash + successful receipt.
+ * Throws before signing when the simulation reverts or gas is short (nothing sent); a reverted
+ * receipt is ACTION_REJECTED (definite); anything unreadable after the broadcast is ORDER_PENDING.
+ */
+export async function sendMasterTx(rpc, t, sign) {
+    let estimate;
+    try {
+        estimate = await rpc.estimateGas({ from: t.from, to: t.to, data: t.data, value: t.value });
+    }
+    catch (e) {
+        throw new PerpError("ACTION_REJECTED", `${t.venue} ${t.label}: simulation on ${t.chainLabel} failed (${e instanceof Error ? e.message : String(e)}) — nothing was sent`, {
+            exchange: t.venue, chainId: t.chainId,
+        });
+    }
+    const gasLimit = estimate + (estimate * GAS_HEADROOM_PCT) / 100n;
+    const fee = await rpc.getFeeData();
+    // EIP-1559 chains price with maxFee / priority; a chain whose blocks carry no base fee (BNB Chain
+    // reports baseFeePerGas 0, so ethers returns maxFeePerGas null) is priced with a legacy gasPrice.
+    const eip1559 = fee.maxFeePerGas !== null && fee.maxPriorityFeePerGas !== null;
+    if (!eip1559 && fee.gasPrice === null) {
+        throw new PerpError("EXCHANGE_ERROR", `${t.venue}: the ${t.chainLabel} RPC returned no fee data — nothing was sent`, { exchange: t.venue });
+    }
+    const pricePerGas = eip1559 ? fee.maxFeePerGas : fee.gasPrice;
+    const need = gasLimit * pricePerGas + t.value;
+    const native = await rpc.getBalance(t.from);
+    if (native < need) {
+        throw new PerpError("INSUFFICIENT_BALANCE", `${t.label} needs up to ${need} wei of ${t.chainLabel} native token (gas${t.value > 0n ? " + value" : ""}); wallet ${t.from} has ${native}`, {
+            exchange: t.venue, remediation: `Fund ${t.from} with native gas token on ${t.chainLabel} (chainId ${t.chainId}), then retry`,
+        });
+    }
+    const nonce = await rpc.getTransactionCount(t.from, "pending");
+    const common = { chainId: BigInt(t.chainId), nonce, to: t.to, data: t.data, value: t.value, gasLimit };
+    const tx = eip1559
+        ? Transaction.from({ ...common, type: 2, maxFeePerGas: fee.maxFeePerGas, maxPriorityFeePerGas: fee.maxPriorityFeePerGas })
+        : Transaction.from({ ...common, type: 0, gasPrice: fee.gasPrice });
+    tx.signature = Signature.from(await sign(tx));
+    if (tx.from === null || !sameAddress(tx.from, t.from)) {
+        throw new PerpError("SIGNATURE_FAILED", `${t.label} tx recovered signer ${tx.from}, expected ${t.from} — nothing was sent`, { exchange: t.venue });
+    }
+    const txHash = tx.hash;
+    if (txHash === null)
+        throw new Error(`${t.label}: signed transaction has no hash`);
+    try {
+        // The raw RPC call only: ethers' broadcastTransaction also reads the block number and
+        // re-checks the hash, so it can throw after the node already accepted the transaction.
+        await rpc.send("eth_sendRawTransaction", [tx.serialized]);
+    }
+    catch (e) {
+        // No connection at all → definitely not sent. "insufficient funds" → the node refused it.
+        // Anything else (timeout, reset, 5xx, "already known", "nonce too low" from a proxy that
+        // retried) may mean the transaction IS in the mempool: wait for the hash below.
+        if (isConnectFailure(e)) {
+            throw new PerpError("EXCHANGE_UNREACHABLE", `${t.venue} ${t.label}: could not connect to the ${t.chainLabel} RPC — nothing was sent`, { exchange: t.venue });
+        }
+        if (e.code === "INSUFFICIENT_FUNDS") {
+            throw new PerpError("ACTION_REJECTED", `${t.venue} ${t.label}: the ${t.chainLabel} RPC refused the transaction (${e instanceof Error ? e.message : String(e)}) — nothing was sent`, {
+                exchange: t.venue, chainId: t.chainId,
+            });
+        }
+    }
+    let receipt;
+    try {
+        receipt = await rpc.waitForTransaction(txHash, 1, EVM_RECEIPT_TIMEOUT_MS);
+    }
+    catch (e) {
+        throw txOutcomeUnknown(t, txHash, e.code === "TIMEOUT"
+            ? `not mined within ${EVM_RECEIPT_TIMEOUT_MS / 1000}s`
+            : `receipt read failed (${e instanceof Error ? e.message : String(e)})`);
+    }
+    if (receipt === null)
+        throw txOutcomeUnknown(t, txHash, `not mined within ${EVM_RECEIPT_TIMEOUT_MS / 1000}s`);
+    if (receipt.status !== 1) {
+        throw new PerpError("ACTION_REJECTED", `${t.venue} ${t.label}: transaction ${txHash} reverted on ${t.chainLabel} — nothing was moved`, {
+            exchange: t.venue, txHash, chainId: t.chainId,
+        });
+    }
+    return { txHash, receipt };
+}
+/**
+ * The OWS master wallet as a transaction signer. On-chain master transactions are signed only by
+ * an OWS wallet (digest derived inside the signer); no master / a raw private key → NO_SIGNER_AVAILABLE.
+ */
+export async function loadMasterEvmSigner(venue, opts, action) {
+    const { resolveOwsMaster } = await import("./config.js");
+    const master = await resolveOwsMaster(venue, opts);
+    if (master === null) {
+        throw new PerpError("NO_SIGNER_AVAILABLE", `${action} is an on-chain transaction signed by the OWS master wallet, which is not selected on this computer`, {
+            exchange: venue,
+            remediation: "Import the master wallet into the OWS vault (perp wallet import --name <name> --chain evm), then perp wallet use <name> or pass --ows <name>",
+        });
+    }
+    const { OwsEvmSigner: Signer } = await import("./signer/ows-evm.js");
+    return Signer.create(master.wallet, master.passphrase);
+}

package/dist/exchanges/adapter-network.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The network an adapter instance was created for. Legacy adapters keep it in private fields of
+ * different shapes, so the creator registers it here (cli-program createVenueAdapter, MCP
+ * getAdapter); TradingV2 adapters also expose `network` themselves. Unknown → null (callers that
+ * need it refuse; never a guessed network).
+ */
+import type { ExchangeAdapter } from "./interface.js";
+import type { Network } from "./venue-types.js";
+export declare function registerAdapterNetwork(adapter: ExchangeAdapter, network: Network): void;
+export declare function adapterNetworkOf(adapter: ExchangeAdapter): Network | null;

package/dist/exchanges/adapter-network.js

@@ -0,0 +1,10 @@
+const networks = new WeakMap();
+export function registerAdapterNetwork(adapter, network) {
+    networks.set(adapter, network);
+}
+export function adapterNetworkOf(adapter) {
+    const own = adapter.network;
+    if (own === "mainnet" || own === "testnet")
+        return own;
+    return networks.get(adapter) ?? null;
+}

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

@@ -0,0 +1,196 @@
+/**
+ * Arcus adapter — native TradingV2 + legacy ExchangeAdapter shim (design §10.7).
+ *
+ * Signing: the agent API key is an Ed25519 key in OWS wallet
+ * `meta.agentWalletName` (raw signMessage on the Solana account — no prefix).
+ * Account = meta.ownerAddress, subaccount = meta.accountIndex. Without an agent
+ * (master creds only, for spot swaps) every perp private call throws
+ * AGENT_NOT_REGISTERED from requireAccount().
+ *
+ * Order entry rules (docs.arcus.xyz, design §10.10):
+ * - every order carries goodTilTime ≥ 1 month ahead (ARCUS_GOOD_TIL_HORIZON_MS),
+ *   body in µs, signed `g` in ns;
+ * - market orders = IOC LIMIT at a protection price derived from mark and an
+ *   explicit slippage bound, rejected locally when > 10 % from mark;
+ * - TIF (design §13.3): common GTC is sent as GTT with goodTil = now +
+ *   ARCUS_GOOD_TIL_HORIZON_MS (recorded as execution.expiresAt); IOC / FOK / ALO
+ *   are native; a limit order without a TIF is GTC;
+ * - clientId is always sent (orderAck async) and every OrderResult from a
+ *   placement is `accepted` / `pending` unless the gateway already had state;
+ * - stop / TP-SL orders exist only as batchPlaceOrders groupings: a standalone
+ *   stop is a 1-leg `partialTpsl` (reduce-only), TP/SL attached to an entry is
+ *   an `entryTpsl` bundle.
+ */
+import type { EvmSigner } from "../../signer/interface.js";
+import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade } from "../interface.js";
+import type { ResolvedSlippage } from "../slippage.js";
+import { type TradingV2 } from "../trading-v2.js";
+import type { VenueCreateContext, VenueDefinition } from "../venue.js";
+import { type AmendRequest, type CancelResult, type LeverageResult, type Network, type OrderRef, type OrderRequest, type OrderResult, type VenueMarket } from "../venue-types.js";
+/**
+ * goodTilTime horizon. Arcus rejects anything nearer than one month at
+ * handling time (31 days covers every calendar month); the docs' examples use
+ * now + 40 days, which also leaves headroom for clock skew.
+ */
+export declare const ARCUS_GOOD_TIL_HORIZON_MS: number;
+/** Arcus rejects MARKET protection prices more than 10 % from mark (also enforced locally for IOC limits). */
+export declare const ARCUS_MAX_PROTECTION_DEVIATION = 0.1;
+/** clientId max (36) minus the "-tp"/"-sl" suffix of entryTpsl child legs. */
+export declare const ARCUS_TPSL_CLIENT_ID_MAX = 33;
+export declare class ArcusAdapter implements ExchangeAdapter, TradingV2 {
+    readonly name: "arcus";
+    readonly venue: VenueDefinition;
+    readonly network: Network;
+    private readonly caps;
+    private readonly client;
+    private readonly account;
+    private readonly masterCreds;
+    private readonly masterPk;
+    private markets;
+    constructor(def: VenueDefinition, ctx: VenueCreateContext);
+    /**
+     * Single guard for every perp private call (orders / cancel / amend /
+     * leverage / private reads / withdraw): they all need the Ed25519 agent key.
+     * Master-only adapters (spot swaps) and read-only adapters land here.
+     */
+    private requireAccount;
+    private accountQuery;
+    private loadMarkets;
+    private market;
+    private symbolOf;
+    /** Protection price: slippage from `ref`, aligned toward crossing on the tier tick, ≤ 10 % from `ref`. */
+    private protectionPrice;
+    /** Limit price must sit on its tier's tick; the signed integer always uses the top-level tickSize. */
+    private limitTicks;
+    private leg;
+    private signLeg;
+    /**
+     * Placement / modify acknowledgement → OrderResult.
+     *
+     * filledSize (M9): on the 202 path the body is an ACK "carrying no terminal
+     * state" and the enrichment fields (filledSize, remainingSize) are omitted
+     * (openapi OrderResponse / BatchOrderItemResponse / ModifyOrderResponse). An
+     * ACK has not been matched yet, so it has no fills by definition: "0" is used
+     * ONLY for status "accepted" (finality pending). On the 200 path the fill is
+     * read from filledSize, else derived as quantity − remainingSize (the docs
+     * define filledSize = originalSize − remainingSize); otherwise it is unknown
+     * and EXCHANGE_ERROR is thrown (the order exists — do not retry blindly).
+     */
+    private resultFromPlace;
+    /** Order shape: filledSize is optional and documented as originalSize − remainingSize (both required). */
+    private filledOf;
+    private orderResultFromRaw;
+    /** TP/SL classification of a reduce-only trigger relative to the current mark. */
+    private tpslType;
+    private findOrder;
+    getVenueMarkets(): Promise<VenueMarket[]>;
+    placeOrder(input: OrderRequest): Promise<OrderResult>;
+    /** Size flooring is surfaced, never silent (L2): wrap venueRaw with requested/placed sizes. */
+    private withFloorNote;
+    /** batchPlaceOrders; returns the first leg's result, throws if any leg failed validation. */
+    private sendBatch;
+    /**
+     * modifyOrder (docs modify-order / authentication).
+     *
+     * Size: the CLI's `req.size` is the new OPEN (unfilled) size (design §13.4), while
+     * Arcus modifies take the order's new TOTAL size, filled quantity included
+     * (OrderRejectionReason MODIFY_SIZE_ALREADY_FILLED: "the order's new TOTAL size,
+     * filled quantity included"). So body `quantity` and signed `q` are
+     * filledSize (as read just before) + new open size. A new open size ≤ 0 is a
+     * cancel, not a modify. A fill that races the modify shrinks the resting
+     * remainder; if fills reach the new total the venue cancels the order and rejects
+     * with MODIFY_SIZE_ALREADY_FILLED — reported as the order's read-back (cancelled) state.
+     *
+     * Identity: the body carries `orderId` only (exactly one of orderId / clientId);
+     * the signed payload follows ARCUS_MODIFY_SIGNED_IDENTITY (UNVERIFIED, signing.ts).
+     * g/r/s/t echo the resting order; `clientTime` = signed `ct` = X-Timestamp.
+     */
+    amendOrder(req: AmendRequest): Promise<OrderResult>;
+    /**
+     * A modify ack (ACK / OPEN) is not the edited order's state: read the order back
+     * (GET /v1/order/{id}, bounded 5 × 1 s). Final when it is terminal (filled / cancelled /
+     * rejected), or resting with the new price and total size; otherwise the ack stays pending.
+     */
+    private confirmModify;
+    /**
+     * MODIFY_SIZE_ALREADY_FILLED: fills reached the new total, so the venue cancelled the
+     * original order. Report the order's read-back state (cancelled, with its real fills).
+     */
+    private modifyAlreadyFilled;
+    cancelByRef(symbol: string, ref: OrderRef): Promise<CancelResult>;
+    /**
+     * Every open order (GET /v1/openOrders pages hold ≤ 1000 rows, newest first; the next
+     * page is `to` = the oldest `createdAt` seen, inclusive → dedupe by orderId).
+     */
+    private allOpenOrders;
+    cancelAllV2(symbol: string | null): Promise<CancelResult>;
+    applyLeverage(symbol: string, leverage: number, marginMode: "cross" | "isolated" | null): Promise<LeverageResult>;
+    /**
+     * Per-market leverage / margin mode: GET /v1/leverages (docs.arcus.xyz openapi getLeverages:
+     * "Returns the effective leverage and margin mode (CROSS/ISOLATED) for `(address,
+     * accountIndex)` across every market … Each entry reflects the user's leverage override (set
+     * via `POST /v1/setLeverage`) when one exists, otherwise the market default"; LeverageEntry
+     * requires marketId, marketDisplayName, leverage (integer ≥ 1), isolated, marginMode).
+     */
+    getMarketSettings(): Promise<Array<{
+        symbol: string;
+        leverage: number;
+        marginMode: "cross" | "isolated";
+    }>>;
+    getOrderStatus(symbol: string, ref: OrderRef): Promise<OrderResult>;
+    getMarkets(): Promise<ExchangeMarketInfo[]>;
+    getOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getRecentTrades(symbol: string, limit?: number): Promise<ExchangeTrade[]>;
+    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 rawPositions;
+    getBalance(): Promise<ExchangeBalance>;
+    getPositions(): Promise<ExchangePosition[]>;
+    private toLegacyOrders;
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
+    /** `clientOrderId`: the caller's id when given; otherwise one is generated (orderAck async needs one). */
+    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>;
+    editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
+    cancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    cancelAllOrders(symbol?: string): Promise<unknown>;
+    setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<unknown>;
+    /** `opts.slippage` (resolveSlippage() output) is required for a stop-market: its leg is protection-priced at trigger ± bound. */
+    stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
+        limitPrice?: string;
+        reduceOnly?: boolean;
+        triggerType?: "mark" | "last" | "mid";
+        slippage?: ResolvedSlippage;
+    }): Promise<unknown>;
+    private masterSigner;
+    private requireMasterKey;
+    /** Master EVM signer for on-chain actions outside the Arcus API (spot swaps, design §12.4 #7). */
+    masterEvmSigner(): Promise<EvmSigner>;
+    /** Sign an unsigned EVM transaction with the master key (digest derived here). Returns a 65-byte 0x signature. */
+    signMasterTransaction(tx: import("ethers").Transaction): Promise<string>;
+    /** The only valid withdraw destination: the account owner (needs the agent API key). */
+    get withdrawDestination(): `0x${string}`;
+    /** Withdraw-to-self (Arcus v0 has no separate recipient). `amount` in USDG. */
+    withdraw(amount: string, destination: string, _opts?: {
+        assetId?: number;
+        routeType?: number;
+    }): Promise<unknown>;
+}