perp-cli 0.12.17 → 0.14.0

package/dist/strategies/split-order.d.ts

@@ -1,22 +1,36 @@
 /**
  * Orderbook-aware split order execution.
  *
- * Unlike TWAP (time-based splitting), this strategy reads the orderbook
- * before each slice and calculates optimal slice sizes based on available
- * depth. Each slice is placed as an IOC limit order at the worst acceptable
- * price within the slippage tolerance, ensuring no sweep beyond the target.
+ * The USD total is converted ONCE to a base size (at the opening best price, floored to the
+ * venue lot) and that size is split across the slices in whole lots. Every slice is an IOC
+ * limit at the worst acceptable price within the slippage tolerance (on the venue tick), and
+ * its fill is VERIFIED (placePerpVerified: venue-final IOC outcome or measured position delta)
+ * — a resolved order call is never counted as a fill.
+ *
+ * Before anything is sent the plan is checked against the venue minimums: a slice below the
+ * venue's minimum size / order value refuses the whole run (SIZE_TOO_SMALL, nothing sent).
  *
  * Flow per slice:
  *   1. Fetch fresh orderbook
- *   2. Walk levels via computeExecutableSize to find fillable amount
- *   3. Place IOC limit at best price + slippage tolerance
- *   4. Wait for book to refresh, then repeat
+ *   2. Slice = remaining size / slices left (whole lots; the last slice takes the rest)
+ *   3. Place IOC limit at best price ± slippage tolerance, verify the fill
+ *   4. Wait for the book to refresh, then repeat
+ * A slice with an unknown outcome stops the run (nothing is resent); a definite rejection
+ * (incl. an IOC that filled nothing) leaves its size to the following slices.
  */
 import type { ExchangeAdapter } from "../exchanges/index.js";
+import { PerpError } from "../errors.js";
 export interface SplitOrderParams {
     symbol: string;
     side: "buy" | "sell";
     totalSizeUsd: number;
+    /** Venue lot step of the market (required: slices are sized in whole lots). */
+    stepSize: string;
+    /** Venue price tick; null = the venue publishes none (Hyperliquid) → the orderbook's price precision is used. */
+    tickSize: string | null;
+    /** Venue-published order minimums (null = none published). */
+    minSize: string | null;
+    minNotional: string | null;
     maxSlippagePct?: number;
     maxSlices?: number;
     delayMs?: number;
@@ -26,24 +40,38 @@ export interface SplitSlice {
     index: number;
     size: string;
     price: string;
-    notionalUsd: number;
-    slippagePct: number;
-    method: "limit_ioc" | "market";
-    status: "filled" | "partial" | "failed";
+    /** Verified filled base size; null = outcome unknown. */
+    filledSize: string | null;
+    /** Venue-reported average fill price; null = the venue did not report one. */
+    avgFillPrice: string | null;
+    method: "limit_ioc";
+    status: "filled" | "partial" | "rejected" | "unknown";
+    error: string | null;
 }
 export interface SplitOrderResult {
     symbol: string;
     side: "buy" | "sell";
     requestedUsd: number;
-    filledUsd: number;
-    filledSize: number;
-    avgPrice: number;
-    totalSlippagePct: number;
+    /** Base size the USD total was converted to (opening best price, floored to the lot). */
+    requestedSize: string;
+    filledSize: string;
+    /** Filled notional at the reported fill prices; null when a filled slice has no reported price. */
+    filledUsd: number | null;
+    /** Size-weighted average of the venue-reported fill prices; null when any filled slice has none. */
+    avgPrice: string | null;
+    totalSlippagePct: number | null;
     slices: SplitSlice[];
-    status: "complete" | "partial" | "failed";
+    /** complete = the whole size filled; partial = some; failed = nothing filled (all definite); unknown = a slice's outcome is unknown. */
+    status: "complete" | "partial" | "failed" | "unknown";
     runtime: number;
 }
 /**
- * Execute a split order: orderbook-aware slicing with IOC limits.
+ * The error a split run that did not fill completely must surface (never ok:true): ORDER_PENDING
+ * when a slice's outcome is unknown, ORDER_REJECTED when nothing filled and every slice is
+ * definite, ORDER_PARTIAL when only part filled. null = complete.
+ */
+export declare function splitIncompleteError(venue: string, r: SplitOrderResult): PerpError | null;
+/**
+ * Execute a split order: lot-sized slices of the total, IOC limits, verified fills.
  */
 export declare function runSplitOrder(adapter: ExchangeAdapter, params: SplitOrderParams, log?: (msg: string) => void): Promise<SplitOrderResult>;

package/dist/strategies/split-order.js

@@ -1,136 +1,202 @@
 /**
  * Orderbook-aware split order execution.
  *
- * Unlike TWAP (time-based splitting), this strategy reads the orderbook
- * before each slice and calculates optimal slice sizes based on available
- * depth. Each slice is placed as an IOC limit order at the worst acceptable
- * price within the slippage tolerance, ensuring no sweep beyond the target.
+ * The USD total is converted ONCE to a base size (at the opening best price, floored to the
+ * venue lot) and that size is split across the slices in whole lots. Every slice is an IOC
+ * limit at the worst acceptable price within the slippage tolerance (on the venue tick), and
+ * its fill is VERIFIED (placePerpVerified: venue-final IOC outcome or measured position delta)
+ * — a resolved order call is never counted as a fill.
+ *
+ * Before anything is sent the plan is checked against the venue minimums: a slice below the
+ * venue's minimum size / order value refuses the whole run (SIZE_TOO_SMALL, nothing sent).
  *
  * Flow per slice:
  *   1. Fetch fresh orderbook
- *   2. Walk levels via computeExecutableSize to find fillable amount
- *   3. Place IOC limit at best price + slippage tolerance
- *   4. Wait for book to refresh, then repeat
+ *   2. Slice = remaining size / slices left (whole lots; the last slice takes the rest)
+ *   3. Place IOC limit at best price ± slippage tolerance, verify the fill
+ *   4. Wait for the book to refresh, then repeat
+ * A slice with an unknown outcome stops the run (nothing is resent); a definite rejection
+ * (incl. an IOC that filled nothing) leaves its size to the following slices.
  */
 import { computeExecutableSize } from "../liquidity.js";
 import { logExecution } from "../execution-log.js";
-/**
- * Infer price precision (decimal places) from an orderbook price string.
- */
+import { PerpError, extractErrorMessage, isDefiniteOrderFailure } from "../errors.js";
+import { alignComputedLimitPrice } from "../bot/quote-rules.js";
+import { alignProtectionPrice, floorToStep, formatComputedPrice, toUnitsExact, unitsToString } from "../exchanges/precision.js";
+import { placePerpVerified } from "../bot/perp-order.js";
+import { reportedAvgFillPrice } from "../exchanges/ioc-outcome.js";
+/** Decimal places of an orderbook price string. */
 function pricePrecision(priceStr) {
     return priceStr.includes(".") ? priceStr.split(".")[1].length : 0;
 }
 /**
- * Execute a split order: orderbook-aware slicing with IOC limits.
+ * IOC limit for a slice: best ± slippage, aligned to the tick TOWARD the best price (never
+ * beyond the tolerance); without a tick, cut to the orderbook's own price precision.
+ */
+function sliceLimitPrice(best, side, maxSlippagePct, tickSize) {
+    const raw = Number(best) * (side === "buy" ? 1 + maxSlippagePct / 100 : 1 - maxSlippagePct / 100);
+    if (tickSize === null)
+        return raw.toFixed(pricePrecision(best));
+    const aligned = alignProtectionPrice(raw.toFixed(12), tickSize, side === "buy" ? "sell" : "buy");
+    // A tolerance smaller than one tick aligns back onto / past the best price: the best price itself still crosses.
+    const crosses = side === "buy" ? Number(aligned) >= Number(best) : Number(aligned) <= Number(best);
+    return crosses ? aligned : best;
+}
+function belowMinimum(size, price, p) {
+    if (p.minSize !== null && Number(size) < Number(p.minSize))
+        return `size ${p.minSize}`;
+    if (p.minNotional !== null && Number(size) * price < Number(p.minNotional))
+        return `order value $${p.minNotional}`;
+    return null;
+}
+/**
+ * The error a split run that did not fill completely must surface (never ok:true): ORDER_PENDING
+ * when a slice's outcome is unknown, ORDER_REJECTED when nothing filled and every slice is
+ * definite, ORDER_PARTIAL when only part filled. null = complete.
+ */
+export function splitIncompleteError(venue, r) {
+    if (r.status === "complete")
+        return null;
+    const what = `${venue} split ${r.side} $${r.requestedUsd} ${r.symbol}`;
+    const details = { exchange: venue, result: r };
+    const check = `perp account positions -e ${venue}`;
+    if (r.status === "unknown") {
+        return new PerpError("ORDER_PENDING", `${what}: the outcome of slice ${r.slices.findIndex(s => s.status === "unknown") + 1} is unknown; ${r.filledSize} of ${r.requestedSize} verified filled`, {
+            ...details, remediation: `Do NOT resubmit — the slice may have executed. Check the position: ${check}`,
+        });
+    }
+    if (r.status === "failed") {
+        const why = r.slices.map(s => s.error).filter(e => e !== null).join("; ");
+        return new PerpError("ORDER_REJECTED", `${what}: nothing filled${why !== "" ? ` — ${why}` : r.slices.length === 0 ? " — no slice was sent" : ""}`, details);
+    }
+    return new PerpError("ORDER_PARTIAL", `${what}: ${r.filledSize} of ${r.requestedSize} filled`, {
+        ...details, remediation: `The filled part is open. Check the position: ${check}, then send the remainder as a new order if still wanted.`,
+    });
+}
+/**
+ * Execute a split order: lot-sized slices of the total, IOC limits, verified fills.
  */
 export async function runSplitOrder(adapter, params, log = console.log) {
-    const { symbol, side, totalSizeUsd, maxSlippagePct = 0.3, maxSlices = 10, delayMs = 1000, minSliceUsd = 100, } = params;
+    const { symbol, side, totalSizeUsd, stepSize, tickSize, maxSlippagePct = 0.3, maxSlices = 10, delayMs = 1000, minSliceUsd = 100, } = params;
     const startedAt = Date.now();
-    const slices = [];
-    let remainingUsd = totalSizeUsd;
-    let totalFilledSize = 0;
-    let totalFilledNotional = 0;
-    // Capture initial best price for overall slippage calculation
-    let initialBestPrice = 0;
-    try {
-        const initialBook = await adapter.getOrderbook(symbol);
-        const initialLevels = side === "buy" ? initialBook.asks : initialBook.bids;
-        if (initialLevels.length > 0) {
-            initialBestPrice = Number(initialLevels[0][0]);
-        }
+    if (!(totalSizeUsd > 0) || !(minSliceUsd > 0) || !Number.isInteger(maxSlices) || maxSlices < 1 || !(maxSlippagePct > 0)) {
+        throw new PerpError("INVALID_PARAMS", `split ${symbol}: usd, --min-slice and --max-slippage must be > 0 and --max-slices a whole number ≥ 1`);
+    }
+    // ── Plan (nothing is sent before every slice passes) ──
+    const openingBook = await adapter.getOrderbook(symbol);
+    const openingLevels = side === "buy" ? openingBook.asks : openingBook.bids;
+    if (openingLevels.length === 0) {
+        throw new PerpError("PRICE_STALE", `${adapter.name} ${symbol}: no ${side === "buy" ? "asks" : "bids"} in the orderbook — nothing was sent`, { exchange: adapter.name });
+    }
+    const initialBestPrice = Number(openingLevels[0][0]);
+    if (!(initialBestPrice > 0)) {
+        throw new PerpError("PRICE_STALE", `${adapter.name} ${symbol}: unusable best price ${openingLevels[0][0]} — nothing was sent`, { exchange: adapter.name });
+    }
+    const sliceCount = Math.min(maxSlices, Math.floor(totalSizeUsd / minSliceUsd));
+    if (sliceCount < 1) {
+        throw new PerpError("SIZE_TOO_SMALL", `split ${symbol}: $${totalSizeUsd} is below --min-slice $${minSliceUsd}; nothing was sent`, {
+            exchange: adapter.name, remediation: "Lower --min-slice or use a larger total",
+        });
     }
-    catch {
-        // Will be recaptured on first slice
+    const totalSize = floorToStep(totalSizeUsd / initialBestPrice, stepSize);
+    const totalUnits = toUnitsExact(totalSize, stepSize, "size");
+    const smallest = unitsToString(totalUnits / BigInt(sliceCount), stepSize);
+    const under = totalUnits / BigInt(sliceCount) <= 0n ? `lot ${stepSize}` : belowMinimum(smallest, initialBestPrice, params);
+    if (under !== null) {
+        throw new PerpError("SIZE_TOO_SMALL", `${adapter.name} ${symbol}: $${totalSizeUsd} in ${sliceCount} slice(s) gives a slice of ${smallest} (≈ $${(Number(smallest) * initialBestPrice).toFixed(2)} @ ${openingLevels[0][0]}), below the venue minimum ${under}; nothing was sent`, {
+            exchange: adapter.name, slices: sliceCount, sliceSize: smallest, stepSize, minSize: params.minSize, minNotional: params.minNotional,
+            remediation: "Use fewer slices (--max-slices) or a larger total so that every slice meets the venue minimum",
+        });
     }
-    log(`[SPLIT] ${side.toUpperCase()} $${totalSizeUsd.toFixed(0)} of ${symbol} | max slippage: ${maxSlippagePct}% | max slices: ${maxSlices}`);
-    for (let i = 0; i < maxSlices && remainingUsd >= minSliceUsd; i++) {
-        // 1. Fetch fresh orderbook
-        const book = await adapter.getOrderbook(symbol);
+    log(`[SPLIT] ${side.toUpperCase()} $${totalSizeUsd} of ${symbol} = ${totalSize} in ${sliceCount} slice(s) | max slippage: ${maxSlippagePct}%`);
+    const slices = [];
+    let remainingUnits = totalUnits;
+    let filledUnits = 0n;
+    let stopped = false;
+    for (let i = 0; i < sliceCount && remainingUnits > 0n && !stopped; i++) {
+        // 1. Fresh orderbook
+        const book = i === 0 ? openingBook : await adapter.getOrderbook(symbol);
         const levels = side === "buy" ? book.asks : book.bids;
         if (levels.length === 0) {
             log(`[SPLIT] No ${side === "buy" ? "asks" : "bids"} in orderbook, stopping`);
             break;
         }
-        // Capture initial best if we missed it
-        if (initialBestPrice === 0) {
-            initialBestPrice = Number(levels[0][0]);
-        }
-        // 2. Calculate how much we can execute within slippage on this depth
-        const check = computeExecutableSize(levels, remainingUsd, maxSlippagePct);
-        if (check.maxSize <= 0) {
-            log(`[SPLIT] Insufficient liquidity within ${maxSlippagePct}% slippage, stopping`);
+        const best = levels[0][0];
+        // 2. Slice: an even share of what remains, in whole lots (the last slice takes the rest)
+        const slicesLeft = BigInt(sliceCount - i);
+        const sliceUnits = slicesLeft === 1n ? remainingUnits : remainingUnits / slicesLeft;
+        const size = unitsToString(sliceUnits, stepSize);
+        const short = sliceUnits <= 0n ? `lot ${stepSize}` : belowMinimum(size, Number(best), params);
+        if (short !== null) {
+            log(`[SPLIT] Slice ${i + 1}: ${size} is below the venue minimum ${short}, stopping (not sent)`);
             break;
         }
-        // Slice size: what we can fill within slippage, capped by remaining
-        const sliceNotional = Math.min(check.maxSize * check.avgFillPrice, remainingUsd);
-        const sliceSize = sliceNotional / check.avgFillPrice;
-        // 3. Calculate IOC limit price (worst acceptable within slippage)
-        const bestPrice = Number(levels[0][0]);
-        const limitPrice = side === "buy"
-            ? bestPrice * (1 + maxSlippagePct / 100)
-            : bestPrice * (1 - maxSlippagePct / 100);
-        const decimals = pricePrecision(levels[0][0]);
-        const formattedPrice = limitPrice.toFixed(decimals);
-        const formattedSize = sliceSize.toFixed(6);
-        log(`[SPLIT] Slice ${i + 1}: ${formattedSize} @ limit $${formattedPrice} (~$${sliceNotional.toFixed(0)}) | depth: $${check.depthUsd.toFixed(0)}`);
-        // 4. Execute IOC limit order
+        // 3. IOC limit at the worst acceptable price, fill verified
+        const raw = sliceLimitPrice(best, side, maxSlippagePct, tickSize);
+        // No published tick (HL): the venue grid, aligned toward the best price (never past the tolerance).
+        const price = tickSize === null ? await alignComputedLimitPrice(adapter, symbol, side === "buy" ? "buy" : "sell", raw) : raw;
+        const depth = computeExecutableSize(levels, Number(size) * Number(best), maxSlippagePct);
+        log(`[SPLIT] Slice ${i + 1}/${sliceCount}: ${size} @ limit $${price} | depth within ${maxSlippagePct}%: $${depth.depthUsd.toFixed(0)}`);
         let slice;
         try {
-            await adapter.limitOrder(symbol, side, formattedPrice, formattedSize, { tif: "IOC" });
+            const fill = await placePerpVerified(adapter, adapter.name, symbol, side, size, {
+                stepSize,
+                place: () => adapter.limitOrder(symbol, side, price, size, { tif: "IOC" }),
+            });
+            const filled = floorToStep(fill.filledSize, stepSize);
+            const got = toUnitsExact(filled, stepSize, "filled size");
+            filledUnits += got;
+            remainingUnits -= got;
             slice = {
-                index: i,
-                size: formattedSize,
-                price: formattedPrice,
-                notionalUsd: sliceNotional,
-                slippagePct: check.slippagePct,
-                method: "limit_ioc",
-                status: "filled",
+                index: i, size, price, filledSize: filled, avgFillPrice: reportedAvgFillPrice(fill.raw),
+                method: "limit_ioc", status: got >= sliceUnits ? "filled" : "partial", error: null,
             };
-            totalFilledSize += sliceSize;
-            totalFilledNotional += sliceNotional;
-            remainingUsd -= sliceNotional;
-            logExecution({
-                type: "limit_order", exchange: adapter.name, symbol,
-                side, size: formattedSize, price: formattedPrice,
-                notional: sliceNotional, status: "success", dryRun: false,
-                meta: { action: "split-order", slice: i + 1, totalSlices: maxSlices },
-            });
         }
         catch (err) {
-            log(`[SPLIT] Slice ${i + 1} failed: ${err instanceof Error ? err.message : String(err)}`);
+            const definite = isDefiniteOrderFailure(err);
+            const msg = extractErrorMessage(err);
+            log(`[SPLIT] Slice ${i + 1} ${definite ? "refused" : "outcome UNKNOWN"}: ${msg}`);
             slice = {
-                index: i, size: formattedSize, price: formattedPrice,
-                notionalUsd: 0, slippagePct: 0, method: "limit_ioc", status: "failed",
+                index: i, size, price, filledSize: definite ? "0" : null, avgFillPrice: null,
+                method: "limit_ioc", status: definite ? "rejected" : "unknown", error: msg,
             };
-            logExecution({
-                type: "limit_order", exchange: adapter.name, symbol,
-                side, size: formattedSize, price: formattedPrice,
-                notional: 0, status: "failed", dryRun: false,
-                error: err instanceof Error ? err.message : String(err),
-                meta: { action: "split-order", slice: i + 1, totalSlices: maxSlices },
-            });
+            // Unknown outcome: the slice may have executed — never send more on top of it.
+            if (!definite)
+                stopped = true;
         }
         slices.push(slice);
-        // 5. Delay before next slice (let the book refresh)
-        if (remainingUsd >= minSliceUsd && i < maxSlices - 1) {
+        logExecution({
+            type: "limit_order", exchange: adapter.name, symbol, side, size, price,
+            status: slice.status === "unknown" ? "unverified" : slice.status === "rejected" ? "failed" : "success",
+            dryRun: false, ...(slice.error !== null ? { error: slice.error } : {}),
+            meta: { action: "split-order", slice: i + 1, totalSlices: sliceCount, filledSize: slice.filledSize, avgFillPrice: slice.avgFillPrice },
+        });
+        // 4. Let the book refresh
+        if (!stopped && remainingUnits > 0n && i < sliceCount - 1) {
             await new Promise(r => setTimeout(r, delayMs));
         }
     }
-    const avgPrice = totalFilledSize > 0 ? totalFilledNotional / totalFilledSize : 0;
-    const totalSlippage = initialBestPrice > 0
-        ? Math.abs((avgPrice - initialBestPrice) / initialBestPrice) * 100
-        : 0;
-    const status = totalFilledNotional >= totalSizeUsd * 0.95 ? "complete"
-        : totalFilledNotional > 0 ? "partial"
-            : "failed";
-    log(`[SPLIT] Done: ${slices.length} slices | filled $${totalFilledNotional.toFixed(0)}/$${totalSizeUsd.toFixed(0)} | avg price: $${avgPrice.toFixed(2)} | slippage: ${totalSlippage.toFixed(3)}%`);
+    // Average = the venue-reported fill prices, size-weighted; unknown when any filled slice has none.
+    const filledSlices = slices.filter(s => s.filledSize !== null && Number(s.filledSize) > 0);
+    const priced = filledSlices.length > 0 && filledSlices.every(s => s.avgFillPrice !== null);
+    const filledSize = unitsToString(filledUnits, stepSize);
+    const filledUsd = priced ? filledSlices.reduce((sum, s) => sum + Number(s.filledSize) * Number(s.avgFillPrice), 0) : filledUnits === 0n ? 0 : null;
+    const avgNum = priced && filledUsd !== null ? filledUsd / Number(filledSize) : null;
+    const avgPrice = avgNum !== null ? formatComputedPrice(avgNum, tickSize) : null;
+    const totalSlippagePct = avgNum !== null ? Math.abs((avgNum - initialBestPrice) / initialBestPrice) * 100 : null;
+    const status = slices.some(s => s.status === "unknown") ? "unknown"
+        : filledUnits >= totalUnits ? "complete"
+            : filledUnits > 0n ? "partial"
+                : "failed";
+    log(`[SPLIT] Done: ${slices.length} slice(s) | filled ${filledSize}/${totalSize} | avg price: ${avgPrice !== null ? `$${avgPrice}` : "not reported"}`);
     return {
         symbol, side,
         requestedUsd: totalSizeUsd,
-        filledUsd: totalFilledNotional,
-        filledSize: totalFilledSize,
+        requestedSize: totalSize,
+        filledSize,
+        filledUsd,
         avgPrice,
-        totalSlippagePct: totalSlippage,
+        totalSlippagePct,
         slices,
         status,
         runtime: (Date.now() - startedAt) / 1000,

package/dist/strategies/trailing-stop.d.ts

@@ -7,7 +7,8 @@ export interface TrailingStopParams {
 }
 export interface TrailingStopResult {
     triggered: boolean;
-    reason: "triggered" | "cancelled" | "no_position";
+    /** position_gone = the position was closed / flipped before the trigger fired (nothing sent). */
+    reason: "triggered" | "cancelled" | "no_position" | "position_gone";
     peakPrice?: number;
     triggerPrice?: number;
     changePct?: number;

package/dist/strategies/trailing-stop.js

@@ -1,10 +1,17 @@
+import { assertCanClosePositions } from "../exchanges/trading-v2.js";
 import { updateJobState } from "../jobs.js";
+import { invalidateCache } from "../cache.js";
 import { logExecution } from "../execution-log.js";
+import { PerpError } from "../errors.js";
+import { closePerpVerified } from "../bot/perp-order.js";
+import { isPositionGone } from "../bot/strategies/funding-arb-utils.js";
 export async function runTrailingStop(adapter, params, jobId, log = console.log) {
     const { symbol, trailPct } = params;
     const intervalMs = (params.intervalSec ?? 5) * 1000;
     const activationPrice = params.activationPrice;
     const startedAt = Date.now();
+    // Unattended: the close fires later, with nobody watching — refused up front on a gated venue.
+    assertCanClosePositions(adapter, `Trailing stop on ${adapter.name}`);
     // Auto-detect position side
     const positions = await adapter.getPositions();
     const pos = positions.find(p => {
@@ -19,6 +26,39 @@ export async function runTrailingStop(adapter, params, jobId, log = console.log)
     const positionSide = pos.side;
     const closeSide = positionSide === "long" ? "sell" : "buy";
     const posSize = pos.size;
+    /**
+     * At trigger time: re-read the position (it may have shrunk, grown, flipped or closed since
+     * start) and close exactly the live size, reduce-only and verified (closePerpVerified: one
+     * residual close). Returns the size closed, or null when the position is gone (nothing sent /
+     * the venue rejected a reduce-only close of a flat position). An unknown outcome (ORDER_PENDING)
+     * or a residual propagates as an error — never resubmitted.
+     */
+    const closeLive = async () => {
+        invalidateCache("acct"); // size the reduce-only close from a fresh read, never a cached position
+        const live = (await adapter.getPositions()).find(p => {
+            const c = p.symbol.toUpperCase();
+            const t = symbol.toUpperCase();
+            return (c === t || c === `${t}-PERP` || c.replace(/-PERP$/, "") === t) && p.side === positionSide;
+        });
+        const liveSize = live === undefined ? null : live.size.replace(/^-/, "");
+        if (liveSize === null || !(Number(liveSize) > 0))
+            return null;
+        log(`[TRAIL] Closing ${positionSide} ${liveSize} ${symbol} (live size, reduce-only)...`);
+        try {
+            const c = await closePerpVerified(adapter, adapter.name, symbol, closeSide, liveSize);
+            if (c.residual > 0) {
+                throw new PerpError("ORDER_PARTIAL", `trailing stop closed ${c.closed} of ${liveSize} ${symbol}; ${c.residual} still open${c.note !== null ? ` (${c.note})` : ""}`, {
+                    exchange: adapter.name, remediation: `Do NOT rerun blindly — check the ${symbol} position on ${adapter.name} and close the rest by hand`,
+                });
+            }
+        }
+        catch (e) {
+            if (isPositionGone(e))
+                return null;
+            throw e;
+        }
+        return liveSize;
+    };
     log(`[TRAIL] ${symbol} ${positionSide} ${posSize} | Trail: ${trailPct}%${activationPrice ? ` | Activation: $${activationPrice}` : ""}`);
     let peakPrice = 0;
     let activated = !activationPrice;
@@ -69,11 +109,14 @@ export async function runTrailingStop(adapter, params, jobId, log = console.log)
                 log(`[TRAIL] $${currentPrice.toFixed(2)} | Peak: $${peakPrice.toFixed(2)} | Drop: ${dropPct.toFixed(2)}%`);
                 if (dropPct >= trailPct) {
                     log(`[TRAIL] TRIGGERED! Price dropped ${dropPct.toFixed(2)}% from peak $${peakPrice.toFixed(2)}`);
-                    log(`[TRAIL] Closing ${positionSide} ${posSize} ${symbol}...`);
-                    await adapter.marketOrder(symbol, closeSide, posSize);
+                    const closedSize = await closeLive();
+                    if (closedSize === null) {
+                        log(`[TRAIL] ${symbol} ${positionSide} position is gone — nothing to close. Exiting.`);
+                        return { triggered: false, reason: "position_gone", peakPrice, positionSide, runtime: (Date.now() - startedAt) / 1000 };
+                    }
                     logExecution({
                         type: "market_order", exchange: adapter.name, symbol,
-                        side: closeSide, size: posSize, status: "success", dryRun: false,
+                        side: closeSide, size: closedSize, status: "success", dryRun: false,
                         meta: { action: "trailing-stop", trailPct, peakPrice, triggerPrice: currentPrice },
                     });
                     return {
@@ -91,11 +134,14 @@ export async function runTrailingStop(adapter, params, jobId, log = console.log)
                 log(`[TRAIL] $${currentPrice.toFixed(2)} | Trough: $${peakPrice.toFixed(2)} | Rise: ${risePct.toFixed(2)}%`);
                 if (risePct >= trailPct) {
                     log(`[TRAIL] TRIGGERED! Price rose ${risePct.toFixed(2)}% from trough $${peakPrice.toFixed(2)}`);
-                    log(`[TRAIL] Closing ${positionSide} ${posSize} ${symbol}...`);
-                    await adapter.marketOrder(symbol, closeSide, posSize);
+                    const closedSize = await closeLive();
+                    if (closedSize === null) {
+                        log(`[TRAIL] ${symbol} ${positionSide} position is gone — nothing to close. Exiting.`);
+                        return { triggered: false, reason: "position_gone", peakPrice, positionSide, runtime: (Date.now() - startedAt) / 1000 };
+                    }
                     logExecution({
                         type: "market_order", exchange: adapter.name, symbol,
-                        side: closeSide, size: posSize, status: "success", dryRun: false,
+                        side: closeSide, size: closedSize, status: "success", dryRun: false,
                         meta: { action: "trailing-stop", trailPct, troughPrice: peakPrice, triggerPrice: currentPrice },
                     });
                     return {

package/dist/strategies/twap.d.ts

@@ -6,13 +6,18 @@ export interface TWAPParams {
     durationSec: number;
     slices?: number;
     maxSlippage?: number;
+    reduceOnly?: boolean;
 }
 export interface TWAPState {
     filled: number;
     remaining: number;
     slicesDone: number;
     totalSlices: number;
-    avgPrice: number;
+    /**
+     * Size-weighted average of the venue-reported FILL prices of the slices; null while any
+     * filled slice has no reported fill price (never the limit / slippage-protection price).
+     */
+    avgPrice: number | null;
     errors: number;
     startedAt: number;
     lastSliceAt: number;

package/dist/strategies/twap.js

@@ -1,5 +1,13 @@
+import { assertCanClosePositions } from "../exchanges/trading-v2.js";
+import { resolveAdapterSlippage } from "../exchanges/slippage.js";
 import { updateJobState } from "../jobs.js";
+import { reportedAvgFillPrice } from "../exchanges/ioc-outcome.js";
+import { filledOf } from "../bot/fill-size.js";
+import { isOutcomeUnknown } from "../bot/perp-order.js";
+import { pendingStop } from "./pending-stop.js";
+import { formatComputedPrice } from "../exchanges/precision.js";
 export async function runTWAP(adapter, params, jobId, log = console.log) {
+    assertCanClosePositions(adapter, `TWAP on ${adapter.name}`);
     const totalSlices = params.slices || Math.max(Math.floor(params.durationSec / 30), 2);
     const sliceSize = params.totalSize / totalSlices;
     const intervalMs = (params.durationSec * 1000) / totalSlices;
@@ -8,7 +16,7 @@ export async function runTWAP(adapter, params, jobId, log = console.log) {
         remaining: params.totalSize,
         slicesDone: 0,
         totalSlices,
-        avgPrice: 0,
+        avgPrice: null,
         errors: 0,
         startedAt: Date.now(),
         lastSliceAt: 0,
@@ -17,6 +25,9 @@ export async function runTWAP(adapter, params, jobId, log = console.log) {
     log(`[TWAP] ${totalSlices} slices, ${sliceSize.toFixed(6)} per slice, ${(intervalMs / 1000).toFixed(1)}s interval`);
     log(`[TWAP] Exchange: ${adapter.name}`);
     let totalCost = 0;
+    let everySlicePriced = true;
+    /** Set when a slice's outcome / fill is unknown: the run stops and surfaces ORDER_PENDING. */
+    let pending = null;
     for (let i = 0; i < totalSlices; i++) {
         if (i > 0) {
             await sleep(intervalMs);
@@ -28,19 +39,26 @@ export async function runTWAP(adapter, params, jobId, log = console.log) {
             break;
         try {
             log(`[TWAP] Slice ${i + 1}/${totalSlices}: ${params.side} ${thisSlice.toFixed(6)} ${params.symbol}...`);
-            const result = await adapter.marketOrder(params.symbol, params.side, String(thisSlice));
+            const result = await adapter.marketOrder(params.symbol, params.side, String(thisSlice), { reduceOnly: params.reduceOnly === true, slippage: resolveAdapterSlippage(adapter, null) });
+            // The venue-reported fill (IOC outcome / OrderResult.filledSize) — never the slice requested.
+            const sliceFilled = filledOf(adapter, result);
+            if (sliceFilled === null) {
+                pending = pendingStop("twap", adapter, params.symbol, `TWAP slice ${i + 1}/${totalSlices} ${params.side} ${thisSlice.toFixed(6)} ${params.symbol} on ${adapter.name}: accepted but the venue reported no fill size`, log);
+                break;
+            }
             state.slicesDone++;
-            state.filled += thisSlice;
+            state.filled += sliceFilled;
             state.remaining = params.totalSize - state.filled;
             state.lastSliceAt = Date.now();
-            // Try to extract fill price from result
-            const fillPrice = Number(result?.price ?? result?.avg_price ?? result?.fill_price ?? 0);
-            if (fillPrice > 0) {
-                totalCost += thisSlice * fillPrice;
-                state.avgPrice = totalCost / state.filled;
-            }
+            // The venue-reported fill price only: the result's `price` is the protection price that was sent.
+            const fillPrice = reportedAvgFillPrice(result);
+            if (fillPrice === null)
+                everySlicePriced = false;
+            else
+                totalCost += sliceFilled * Number(fillPrice);
+            state.avgPrice = everySlicePriced && state.filled > 0 ? Number(formatComputedPrice(totalCost / state.filled)) : null;
             const pct = ((state.filled / params.totalSize) * 100).toFixed(1);
-            log(`[TWAP] Filled ${state.filled.toFixed(6)}/${params.totalSize} (${pct}%)${state.avgPrice > 0 ? ` avg $${state.avgPrice.toFixed(4)}` : ""}`);
+            log(`[TWAP] Filled ${state.filled.toFixed(6)}/${params.totalSize} (${pct}%)${state.avgPrice !== null ? ` avg $${state.avgPrice}` : ""}`);
             // Update job state file if running as background job
             if (jobId) {
                 updateJobState(jobId, {
@@ -56,8 +74,13 @@ export async function runTWAP(adapter, params, jobId, log = console.log) {
             }
         }
         catch (err) {
-            state.errors++;
             const msg = err instanceof Error ? err.message : String(err);
+            if (isOutcomeUnknown(err)) {
+                // Unknown outcome: never resubmitted — the run stops and the symbol is quarantined.
+                pending = pendingStop("twap", adapter, params.symbol, `TWAP slice ${i + 1}/${totalSlices} ${params.side} ${thisSlice.toFixed(6)} ${params.symbol} on ${adapter.name}: outcome unknown (${msg})`, log);
+                break;
+            }
+            state.errors++;
             log(`[TWAP] Slice ${i + 1} error: ${msg}`);
             // Continue — don't abort the whole TWAP for one failed slice
             if (state.errors > totalSlices * 0.5) {
@@ -68,6 +91,11 @@ export async function runTWAP(adapter, params, jobId, log = console.log) {
     }
     const elapsed = ((Date.now() - state.startedAt) / 1000).toFixed(1);
     log(`[TWAP] Complete. Filled ${state.filled.toFixed(6)} in ${elapsed}s, ${state.errors} errors.`);
+    if (pending !== null) {
+        if (jobId)
+            updateJobState(jobId, { status: "error", result: { ...state, error: pending.message } });
+        throw pending;
+    }
     if (jobId) {
         updateJobState(jobId, { status: "done", result: { ...state } });
     }