@gbozee/ultimate 0.0.2-next.73 → 0.0.2-next.74

package/dist/index.cjs

@@ -72038,9 +72038,18 @@ class BaseExchange {
   async previewSpotMarginHedge(_payload) {
     throw new Error("Spot margin hedge preview is not supported on this exchange");
   }
+  async previewFuturesReplay(_payload) {
+    throw new Error("Futures replay preview is not supported on this exchange");
+  }
   async placeSpotMarginHedge(_payload) {
     throw new Error("Spot margin hedge placement is not supported on this exchange");
   }
+  async placeFuturesReplay(_payload) {
+    throw new Error("Futures replay placement is not supported on this exchange");
+  }
+  async placeFuturesExactTrade(_payload) {
+    throw new Error("Futures exact trade placement is not supported on this exchange");
+  }
   async placeSpotLimitOrders(_payload) {}
   async buildCumulative(payload) {
     const {
@@ -72449,19 +72458,198 @@ class BaseExchange {
 // src/exchanges/binance/index.ts
 var import_p_limit = __toESM(require_p_limit(), 1);
 
-// src/exchanges/binance/spot-margin-hedge.ts
+// src/exchanges/binance/futures-replay.ts
 function roundNumber(value2, digits = 8) {
   return Number(value2.toFixed(digits));
 }
-var STOP_LIMIT_SPREAD_PERCENT = 0.0005;
+function parseNumber2(value2) {
+  if (value2 === undefined || value2 === null || value2 === "")
+    return;
+  const parsed = Number(value2);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return;
+  return roundNumber(parsed);
+}
 function normalizeOrderInput(order) {
+  const stop = parseNumber2(order.stop) ?? parseNumber2(order.stopPrice) ?? parseNumber2(order.triggerPrice);
+  const type = order.type ? order.type.toUpperCase() : undefined;
+  const quantity = order.quantity ?? order.qty ?? 0;
+  return {
+    price: roundNumber(Number(order.price)),
+    quantity: roundNumber(Number(quantity)),
+    ...stop ? { stop } : {},
+    ...type && type !== "LIMIT" ? { type } : {}
+  };
+}
+function sortReplayOrders(orders) {
+  return [...orders].sort((left, right) => {
+    const leftTrigger = left.stop ?? left.price;
+    const rightTrigger = right.stop ?? right.price;
+    if (leftTrigger !== rightTrigger)
+      return leftTrigger - rightTrigger;
+    if (left.price !== right.price)
+      return left.price - right.price;
+    return left.quantity - right.quantity;
+  });
+}
+function buildReplayStopLimitPrice(payload) {
+  const spread = payload.stop > 30000 ? 1.00005 : 1.0002;
+  return roundNumber(payload.kind === "long" ? payload.stop * spread ** -1 : payload.stop * spread);
+}
+function normalizeRequestedEntryOrders(orders) {
+  return sortReplayOrders(orders.map((order) => ({
+    price: roundNumber(Number(order.price)),
+    quantity: roundNumber(Number(order.quantity))
+  })));
+}
+function normalizeRequestedStopOrders(payload) {
+  return sortReplayOrders(payload.orders.map((order) => {
+    const stop = parseNumber2(order.stop) ?? roundNumber(Number(order.price));
+    return {
+      price: order.price !== undefined ? roundNumber(Number(order.price)) : buildReplayStopLimitPrice({
+        kind: payload.kind,
+        stop
+      }),
+      quantity: roundNumber(Number(order.quantity)),
+      stop,
+      type: (order.type || "STOP").toUpperCase()
+    };
+  }));
+}
+function normalizeRequestedTakeProfitOrders(orders) {
+  return sortReplayOrders(orders.map((order) => {
+    const stop = parseNumber2(order.stop);
+    const type = order.type?.toUpperCase();
+    return {
+      price: roundNumber(Number(order.price)),
+      quantity: roundNumber(Number(order.quantity)),
+      ...stop ? { stop } : {},
+      ...type ? { type } : stop ? { type: "TAKE_PROFIT" } : {}
+    };
+  }));
+}
+function buildOrderKey(order) {
+  return [
+    order.type || "LIMIT",
+    order.price,
+    order.quantity,
+    order.stop ?? ""
+  ].join(":");
+}
+function buildComparisonBucket(options) {
+  const expected = sortReplayOrders(options.expected);
+  const actual = sortReplayOrders(options.actual);
+  const expected_keys = expected.map(buildOrderKey);
+  const actual_keys = actual.map(buildOrderKey);
   return {
-    price: roundNumber(order.price),
-    quantity: roundNumber(order.quantity)
+    expected,
+    actual,
+    missing: expected_keys.filter((key) => !actual_keys.includes(key)),
+    extra: actual_keys.filter((key) => !expected_keys.includes(key))
+  };
+}
+function buildFuturesReplaySnapshot(payload) {
+  const entry_side = payload.kind === "long" ? "buy" : "sell";
+  const close_side = payload.kind === "long" ? "sell" : "buy";
+  const entry_orders = [];
+  const stop_orders = [];
+  const take_profit_orders = [];
+  for (const order of payload.open_orders) {
+    if (order.kind !== payload.kind)
+      continue;
+    const normalized_order = normalizeOrderInput(order);
+    const type = (normalized_order.type || "LIMIT").toUpperCase();
+    if (order.side === entry_side) {
+      entry_orders.push(normalized_order);
+      continue;
+    }
+    if (order.side !== close_side)
+      continue;
+    if (type.includes("TAKE_PROFIT") || normalized_order.stop === undefined) {
+      take_profit_orders.push(normalized_order);
+      continue;
+    }
+    stop_orders.push(normalized_order);
+  }
+  return {
+    symbol: payload.symbol,
+    kind: payload.kind,
+    current_price: payload.current_price,
+    position: payload.position,
+    open_orders: payload.open_orders.filter((order) => order.kind === payload.kind),
+    entry_orders: sortReplayOrders(entry_orders),
+    stop_orders: sortReplayOrders(stop_orders),
+    take_profit_orders: sortReplayOrders(take_profit_orders)
+  };
+}
+function inferFuturesReplayInputFromLiveOrders(payload) {
+  const snapshot = buildFuturesReplaySnapshot(payload);
+  return {
+    symbol: payload.symbol,
+    kind: payload.kind,
+    current_price: payload.current_price,
+    position: payload.position,
+    entry_orders: snapshot.entry_orders,
+    stop_orders: snapshot.stop_orders,
+    take_profit_orders: snapshot.take_profit_orders
+  };
+}
+function compareFuturesReplayOrders(payload) {
+  const entry = buildComparisonBucket({
+    expected: payload.entry_orders,
+    actual: payload.snapshot.entry_orders
+  });
+  const stop = buildComparisonBucket({
+    expected: payload.stop_orders,
+    actual: payload.snapshot.stop_orders
+  });
+  const take_profit = buildComparisonBucket({
+    expected: payload.take_profit_orders,
+    actual: payload.snapshot.take_profit_orders
+  });
+  return {
+    matches: entry.missing.length === 0 && entry.extra.length === 0 && stop.missing.length === 0 && stop.extra.length === 0 && take_profit.missing.length === 0 && take_profit.extra.length === 0,
+    entry,
+    stop,
+    take_profit
+  };
+}
+function buildFuturesReplayPlan(payload) {
+  return {
+    symbol: payload.symbol,
+    kind: payload.kind,
+    orders_to_cancel: payload.snapshot.open_orders,
+    orders_to_create: {
+      entry: sortReplayOrders(payload.entry_orders),
+      stop: sortReplayOrders(payload.stop_orders),
+      take_profit: sortReplayOrders(payload.take_profit_orders)
+    }
+  };
+}
+function normalizeFuturesReplayInput(payload) {
+  return {
+    entry_orders: normalizeRequestedEntryOrders(payload.entry_orders),
+    stop_orders: normalizeRequestedStopOrders({
+      kind: payload.kind,
+      orders: payload.stop_orders
+    }),
+    take_profit_orders: normalizeRequestedTakeProfitOrders(payload.take_profit_orders)
+  };
+}
+
+// src/exchanges/binance/spot-margin-hedge.ts
+function roundNumber2(value2, digits = 8) {
+  return Number(value2.toFixed(digits));
+}
+var STOP_LIMIT_SPREAD_PERCENT = 0.0005;
+function normalizeOrderInput2(order) {
+  return {
+    price: roundNumber2(order.price),
+    quantity: roundNumber2(order.quantity)
   };
 }
 function sortOrderInputs(orders) {
-  return [...orders].map(normalizeOrderInput).sort((left, right) => left.price - right.price);
+  return [...orders].map(normalizeOrderInput2).sort((left, right) => left.price - right.price);
 }
 function normalizeOrderForComparison(order) {
   const type = (order.type || "limit").toLowerCase();
@@ -72470,9 +72658,9 @@ function normalizeOrderForComparison(order) {
   return {
     side: order.side,
     type,
-    price: roundNumber(order.price),
-    quantity: roundNumber(order.quantity),
-    stop: parsed_stop !== undefined && Number.isFinite(parsed_stop) && parsed_stop > 0 ? roundNumber(parsed_stop) : undefined
+    price: roundNumber2(order.price),
+    quantity: roundNumber2(order.quantity),
+    stop: parsed_stop !== undefined && Number.isFinite(parsed_stop) && parsed_stop > 0 ? roundNumber2(parsed_stop) : undefined
   };
 }
 function normalizeOrders(orders) {
@@ -72495,7 +72683,7 @@ function toPlannedOrders(orders) {
     stop: order.stop
   }));
 }
-function buildOrderKey(order) {
+function buildOrderKey2(order) {
   return [
     order.side,
     order.type,
@@ -72505,8 +72693,8 @@ function buildOrderKey(order) {
   ].join(":");
 }
 function buildDiff(options) {
-  const expectedKeys = options.expected.map(buildOrderKey);
-  const actualKeys = options.actual.map(buildOrderKey);
+  const expectedKeys = options.expected.map(buildOrderKey2);
+  const actualKeys = options.actual.map(buildOrderKey2);
   return {
     missing: expectedKeys.filter((key) => !actualKeys.includes(key)),
     extra: actualKeys.filter((key) => !expectedKeys.includes(key))
@@ -72518,10 +72706,10 @@ function getQuoteAsset(symbol) {
   return target || symbol.slice(-4);
 }
 function sumNotional(orders) {
-  return roundNumber(orders.reduce((sum, order) => sum + order.price * order.quantity, 0), 8);
+  return roundNumber2(orders.reduce((sum, order) => sum + order.price * order.quantity, 0), 8);
 }
 function sumQuantity(orders) {
-  return roundNumber(orders.reduce((sum, order) => sum + order.quantity, 0), 8);
+  return roundNumber2(orders.reduce((sum, order) => sum + order.quantity, 0), 8);
 }
 function buildLongOrderPlacement(options) {
   const { order, current_price } = options;
@@ -72530,7 +72718,7 @@ function buildLongOrderPlacement(options) {
       side: "buy",
       type: "stop_loss_limit",
       price: order.price,
-      stop: roundNumber(order.price * (1 - STOP_LIMIT_SPREAD_PERCENT)),
+      stop: roundNumber2(order.price * (1 - STOP_LIMIT_SPREAD_PERCENT)),
       quantity: order.quantity
     };
   }
@@ -72598,11 +72786,11 @@ function buildSpotMarginHedgePlan(options) {
   }));
   const spot_orders_to_create = options.placement_overrides?.spot || default_spot_orders_to_create;
   const margin_orders_to_create = options.placement_overrides?.margin || default_margin_orders_to_create;
-  const borrow_delta = roundNumber(Math.max(0, options.borrow_amount - options.snapshot.borrowed_quote_amount));
+  const borrow_delta = roundNumber2(Math.max(0, options.borrow_amount - options.snapshot.borrowed_quote_amount));
   const spot_long_notional = sumNotional(spot_long_orders);
-  const transfer_to_spot_amount = roundNumber(Math.max(0, spot_long_notional - options.snapshot.spot_quote_free));
+  const transfer_to_spot_amount = roundNumber2(Math.max(0, spot_long_notional - options.snapshot.spot_quote_free));
   const short_quantity = sumQuantity(short_orders);
-  const transfer_base_to_spot_amount = roundNumber(Math.max(0, short_quantity - options.snapshot.spot_base_free));
+  const transfer_base_to_spot_amount = roundNumber2(Math.max(0, short_quantity - options.snapshot.spot_base_free));
   return {
     borrow_amount: options.borrow_amount,
     borrow_delta,
@@ -74261,6 +74449,30 @@ class BinanceExchange extends BaseExchange {
       throw error;
     }
   }
+  async getFuturesSymbolFormats(symbol) {
+    if (typeof this.client.getExchangeInfo !== "function") {
+      return {
+        price_places: "%.8f",
+        decimal_places: "%.8f"
+      };
+    }
+    try {
+      const exchange_info = await this.client.getExchangeInfo();
+      const symbol_info = exchange_info?.symbols?.find((item) => item.symbol === symbol.toUpperCase());
+      const price_filter = symbol_info?.filters?.find((filter) => filter.filterType === "PRICE_FILTER");
+      const lot_size_filter = symbol_info?.filters?.find((filter) => filter.filterType === "LOT_SIZE");
+      return {
+        price_places: getPrintfFormatFromStepSize(price_filter?.tickSize, "%.8f"),
+        decimal_places: getPrintfFormatFromStepSize(lot_size_filter?.stepSize, "%.8f")
+      };
+    } catch (error) {
+      console.error("Error fetching futures symbol formats:", error);
+      return {
+        price_places: "%.8f",
+        decimal_places: "%.8f"
+      };
+    }
+  }
   async getSpotSymbolFormats(symbol) {
     if (!this.main_client || typeof this.main_client.getExchangeInfo !== "function") {
       return {
@@ -74315,6 +74527,123 @@ class BinanceExchange extends BaseExchange {
     }
     return await getMarginOpenOrders(this.main_client, symbol, isIsolated);
   }
+  async getFuturesReplaySnapshot(payload) {
+    const symbol = payload.symbol.toUpperCase();
+    const [open_orders, position_info, current_price] = await Promise.all([
+      this.getOpenOrders({ symbol }),
+      this.getPositionInfo(symbol),
+      this.getCurrentPrice(symbol)
+    ]);
+    return buildFuturesReplaySnapshot({
+      symbol,
+      kind: payload.kind,
+      current_price,
+      position: {
+        size: position_info[payload.kind]?.size || 0
+      },
+      open_orders
+    });
+  }
+  async previewFuturesReplay(payload) {
+    const snapshot = payload.snapshot ? {
+      ...payload.snapshot,
+      current_price: payload.snapshot.current_price ?? await this.getCurrentPrice(payload.symbol)
+    } : await this.getFuturesReplaySnapshot({
+      symbol: payload.symbol,
+      kind: payload.kind
+    });
+    const shouldInferEntryOrders = !payload.entry_orders || payload.entry_orders.length === 0;
+    const shouldInferStopOrders = !payload.stop_orders || payload.stop_orders.length === 0;
+    const shouldInferTakeProfitOrders = !payload.take_profit_orders || payload.take_profit_orders.length === 0;
+    const inferred_input = shouldInferEntryOrders || shouldInferStopOrders || shouldInferTakeProfitOrders ? inferFuturesReplayInputFromLiveOrders({
+      symbol: payload.symbol,
+      kind: payload.kind,
+      current_price: snapshot.current_price,
+      position: snapshot.position,
+      open_orders: snapshot.open_orders
+    }) : undefined;
+    const explicit_input = normalizeFuturesReplayInput({
+      kind: payload.kind,
+      entry_orders: payload.entry_orders || [],
+      stop_orders: payload.stop_orders || [],
+      take_profit_orders: payload.take_profit_orders || []
+    });
+    const entry_orders = shouldInferEntryOrders ? inferred_input?.entry_orders || [] : explicit_input.entry_orders;
+    const stop_orders = shouldInferStopOrders ? inferred_input?.stop_orders || [] : explicit_input.stop_orders;
+    const take_profit_orders = shouldInferTakeProfitOrders ? inferred_input?.take_profit_orders || [] : explicit_input.take_profit_orders;
+    const requested_input = {
+      symbol: payload.symbol,
+      kind: payload.kind,
+      entry_orders,
+      stop_orders,
+      take_profit_orders
+    };
+    const plan = buildFuturesReplayPlan({
+      ...requested_input,
+      snapshot
+    });
+    const comparison = compareFuturesReplayOrders({
+      ...requested_input,
+      snapshot
+    });
+    return {
+      snapshot,
+      inferred_input,
+      requested_input,
+      plan,
+      comparison
+    };
+  }
+  async placeFuturesReplay(payload) {
+    const preview = await this.previewFuturesReplay(payload);
+    if (!payload.place) {
+      return preview;
+    }
+    const symbol = payload.symbol.toUpperCase();
+    await cancelAllOrders(this.client, symbol, {
+      kind: payload.kind
+    });
+    const refreshed_snapshot = await this.getFuturesReplaySnapshot({
+      symbol,
+      kind: payload.kind
+    });
+    const execution_plan = buildFuturesReplayPlan({
+      symbol,
+      kind: payload.kind,
+      entry_orders: preview.requested_input.entry_orders,
+      stop_orders: preview.requested_input.stop_orders,
+      take_profit_orders: preview.requested_input.take_profit_orders,
+      snapshot: refreshed_snapshot
+    });
+    const { price_places, decimal_places } = await this.getFuturesSymbolFormats(symbol);
+    const entry_orders = execution_plan.orders_to_create.entry.map((order) => ({
+      ...order,
+      side: payload.kind === "long" ? "buy" : "sell",
+      kind: payload.kind
+    }));
+    const stop_orders = execution_plan.orders_to_create.stop.map((order) => ({
+      ...order,
+      side: payload.kind === "long" ? "sell" : "buy",
+      kind: payload.kind,
+      type: order.type || "STOP"
+    }));
+    const take_profit_orders = execution_plan.orders_to_create.take_profit.map((order) => ({
+      ...order,
+      side: payload.kind === "long" ? "sell" : "buy",
+      kind: payload.kind,
+      ...order.stop ? { type: order.type || "TAKE_PROFIT" } : {}
+    }));
+    const execution = entry_orders.length > 0 || stop_orders.length > 0 || take_profit_orders.length > 0 ? await createLimitPurchaseOrdersParallel(this.client, symbol, price_places, decimal_places, [...entry_orders, ...stop_orders, ...take_profit_orders]) : [];
+    return {
+      ...preview,
+      execution_plan,
+      refreshed_snapshot,
+      execution
+    };
+  }
+  async placeFuturesExactTrade(payload) {
+    return await this.placeFuturesReplay(payload);
+  }
   async getSpotMarginHedgeSnapshot(payload) {
     if (!this.main_client) {
       throw new Error("Main client not available for spot and margin trading");

package/dist/index.d.ts

@@ -387,6 +387,29 @@ declare abstract class BaseExchange {
 		max_spot_buy_orders?: number;
 		snapshot?: any;
 	}): Promise<any>;
+	previewFuturesReplay(_payload: {
+		symbol: string;
+		kind: "long" | "short";
+		entry_orders?: Array<{
+			price: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		stop_orders?: Array<{
+			price?: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		take_profit_orders?: Array<{
+			price: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		snapshot?: any;
+	}): Promise<any>;
 	placeSpotMarginHedge(_payload: {
 		borrow_amount?: number;
 		symbol: string;
@@ -403,6 +426,54 @@ declare abstract class BaseExchange {
 		snapshot?: any;
 		place?: boolean;
 	}): Promise<any>;
+	placeFuturesReplay(_payload: {
+		symbol: string;
+		kind: "long" | "short";
+		entry_orders?: Array<{
+			price: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		stop_orders?: Array<{
+			price?: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		take_profit_orders?: Array<{
+			price: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		snapshot?: any;
+		place?: boolean;
+	}): Promise<any>;
+	placeFuturesExactTrade(_payload: {
+		symbol: string;
+		kind: "long" | "short";
+		entry_orders?: Array<{
+			price: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		stop_orders?: Array<{
+			price?: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		take_profit_orders?: Array<{
+			price: number;
+			quantity: number;
+			stop?: number;
+			type?: string;
+		}>;
+		snapshot?: any;
+		place?: boolean;
+	}): Promise<any>;
 	placeSpotLimitOrders(_payload: any): Promise<void>;
 	buildCumulative(payload: {
 		orders: Order$1[];