perp-cli 0.12.15 → 0.14.0

package/dist/commands/arb-auto.d.ts

@@ -1,3 +1,4 @@
+import type { Network } from "../exchanges/venue-types.js";
 import { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
 interface FundingSnapshot {
@@ -14,7 +15,132 @@ interface FundingSnapshot {
     hlMarkPrice: number;
     ltMarkPrice: number;
     astMarkPrice: number;
+    /** Aster per-symbol funding interval (= basis and settlement interval) from /fapi/v3/fundingInfo; null when Aster has no rate. */
+    astHours: number | null;
 }
+export interface LegOrderMinimums {
+    exchange: string;
+    minSize: string | null;
+    minNotional: string | null;
+}
+/**
+ * The venue's published order minimums for `sym` (VenueMarket.minSize / minNotional — the same
+ * source `trade scale-in` checks its levels against); null = the venue publishes none.
+ * A market missing from the venue's list throws (Rule #2: no assumed minimum).
+ */
+export declare function venueOrderMinimums(adapter: ExchangeAdapter, sym: string, network: Network): Promise<{
+    minSize: string | null;
+    minNotional: string | null;
+}>;
+/** The pair's minimums: the larger of the two legs' (both legs trade the same size); 0 = none published. */
+export declare function pairOrderMinimums(legs: readonly LegOrderMinimums[]): {
+    minNotional: number;
+    minSize: number;
+    describe: string;
+    legs: readonly LegOrderMinimums[];
+};
+export type PerpPairOpenResult = 
+/** Both legs open and hedged at `hedged` (base units, both legs). */
+{
+    status: "opened";
+    hedged: string;
+    longFilled: number;
+    shortFilled: number;
+    trimmed: string;
+}
+/** Nothing left open: the long failed definitively, or the short failed and the long was rolled back in full. */
+/** lotSize: the long was definitely rejected for lot size (nothing placed) — the caller may re-size once. */
+ | {
+    status: "not_opened";
+    reason: string;
+    rolledBack: string | null;
+    lotSize: number | null;
+}
+/** Exposure is unknown or unhedged: the symbol was quarantined; `exposure` says what may be open. */
+ | {
+    status: "quarantined";
+    reason: string;
+    exposure: string;
+};
+export type PerpPairCloseResult = {
+    status: "closed";
+}
+/** The long close failed definitively: nothing changed, both legs still open (hedged). */
+ | {
+    status: "failed";
+    reason: string;
+}
+/** Outcome unknown or a leg left unhedged: the symbol was quarantined. */
+ | {
+    status: "quarantined";
+    reason: string;
+};
+/**
+ * Open long `size` on longExch, then short the long's verified fill on shortExch.
+ * `smart` sends the opening legs as IOC limits (smartOrder); rollback / trim are
+ * always reduce-only market orders.
+ */
+export declare function openPerpPairVerified(p: {
+    /** Quarantine source; `sym` is the quarantine (canonical) symbol, longSym / shortSym the venue order symbols. */
+    source: string;
+    sym: string;
+    longAdapter: ExchangeAdapter;
+    longExch: string;
+    longSym: string;
+    shortAdapter: ExchangeAdapter;
+    shortExch: string;
+    shortSym: string;
+    size: string;
+    smart: boolean;
+    log: (m: string) => void;
+    /**
+     * When the short is DEFINITELY rejected for lot size (rejectedLotSize), place ONE short of
+     * the long's verified fill floored to that lot (never resubmitting the long), then trim the
+     * long's excess as usual. Off → the long is rolled back.
+     */
+    shortLotRetry?: boolean;
+}): Promise<PerpPairOpenResult>;
+/**
+ * Close a perp-perp pair: long first, then short — reduce-only, verified, no retry.
+ * A definite failure of the long close changes nothing ("failed": the caller may retry
+ * later and should quarantine after repeated failures). Once the long is closed, any
+ * short failure, an unknown outcome, or a residual that survives one reduce-only residual
+ * close (closePerpVerified) quarantines.
+ */
+export declare function closePerpPairVerified(p: {
+    source: string;
+    sym: string;
+    longAdapter: ExchangeAdapter;
+    longExch: string;
+    longSym: string;
+    longSize: string;
+    shortAdapter: ExchangeAdapter;
+    shortExch: string;
+    shortSym: string;
+    shortSize: string;
+    /** Send each close as a reduce-only IOC limit (smartOrder) instead of a reduce-only market order. */
+    smart: boolean;
+    log: (m: string) => void;
+}): Promise<PerpPairCloseResult>;
+/**
+ * Graceful stop of a daemon loop: SIGINT / SIGTERM (`perp background stop`, Ctrl+C) only REQUEST
+ * the stop — the leg sequence (or rollback) in flight finishes, nothing new starts, then the loop
+ * ends. A repeated signal never exits between two legs (it is logged).
+ */
+export declare function gracefulStop(name: string): {
+    requested: () => boolean;
+    dispose: () => void;
+};
+/** Sleep `ms`, waking within 250 ms once `stop()` is true. */
+export declare function interruptibleSleep(ms: number, stop: () => boolean): Promise<void>;
+/**
+ * Startup: pending-entry records `source` left behind by a process that died mid-entry → the
+ * symbol is quarantined (legs may be open), then the record is cleared. An unreadable pending
+ * file throws (the daemon does not start on unknown exposure).
+ */
+export declare function quarantineOrphanedEntries(network: Network, source: string, log: (m: string) => void): void;
+/** The entry's outcome is recorded: drop its pending record (a failed drop is logged — the next start quarantines it). */
+export declare function finishPendingEntry(network: Network, source: string, symbol: string, log: (m: string) => void): void;
 /**
  * Compute the estimated round-trip cost as a percentage of notional.
  * Round-trip = 4 × taker fee + 2 × slippage (entry + exit for both legs).
@@ -33,15 +159,17 @@ export declare function computeRoundTripCostPct(longExchange: string, shortExcha
  */
 export declare function computeNetSpread(grossAnnualPct: number, holdDays: number, roundTripCostPct: number, bridgeCostUsd?: number, positionSizeUsd?: number): number;
 /**
- * Get the next settlement time for an exchange.
- * @returns Date of next settlement
+ * Get the next settlement time for an exchange (schedule anchored at 00:00 UTC).
+ * `marketIntervalHours` is the market's settlement interval; required for
+ * per-market venues (Aster). Unknown venues throw UNKNOWN_VENUE.
+ * A settlement exactly at `now` counts as the next one.
  */
-export declare function getNextSettlement(exchange: string, now?: Date): Date;
+export declare function getNextSettlement(exchange: string, now?: Date, marketIntervalHours?: number | null): Date;
 /**
  * Check if we are within N minutes before a settlement event on either exchange.
  * If so, we should avoid entering positions (rates may change).
  */
-export declare function isNearSettlement(longExchange: string, shortExchange: string, bufferMinutes?: number, now?: Date): {
+export declare function isNearSettlement(longExchange: string, shortExchange: string, bufferMinutes?: number, now?: Date, marketIntervalFor?: (exchange: string) => number | null): {
     blocked: boolean;
     exchange?: string;
     minutesUntil?: number;