@gbozee/ultimate 0.0.2-next.4 → 0.0.2-next.41

package/dist/mcp-server.cjs

@@ -63321,12 +63321,18 @@ async function initPocketBaseClient(proxy_credentials) {
 
 class AppDatabase {
   pb;
+  drizzlePb;
   email;
   salt;
-  constructor(pb, payload) {
+  root_password;
+  root_email;
+  constructor(pb, payload, drizzlePb) {
     this.pb = pb;
     this.email = payload.email;
     this.salt = payload.salt;
+    this.root_password = payload.db?.password;
+    this.root_email = payload.db?.email;
+    this.drizzlePb = drizzlePb;
     const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
     this[customInspectSymbol] = function() {
       return `AppDatabase { pb: [PocketBase Instance - Sensitive Data Masked] }`;
@@ -63506,6 +63512,13 @@ class AppDatabase {
     return Array.from(new Set(positions.map((p) => p.symbol)));
   }
   async createOrUpdateLiveExchangeInstance(payload) {
+    if (this.drizzlePb) {
+      await this.drizzlePb?.createOrUpdateLiveExchangeInstance(payload);
+      return this.getLiveExchangeInstance({
+        account: payload.account,
+        symbol: payload.symbol
+      });
+    }
     const result = await this.getLiveExchangeInstance(payload);
     if (result) {
       return await this.pb.collection("live_exchange_details").update(result.id, {
@@ -63521,6 +63534,9 @@ class AppDatabase {
     }
   }
   async getLiveExchangeInstance(payload) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.getLiveExchangeInstance(payload);
+    }
     const result = await this.pb.collection("live_exchange_details").getFullList({
       filter: `account.owner:lower="${payload.account.owner.toLowerCase()}" && account.exchange:lower="${payload.account.exchange.toLowerCase()}" && symbol:lower="${payload.symbol.toLowerCase()}"`,
       expand: "account"
@@ -63563,6 +63579,9 @@ class AppDatabase {
     });
   }
   async get_exchange_db_instance(account) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.get_exchange_db_instance(account);
+    }
     let filter = `owner="${account.owner}" && exchange="${account.exchange}"`;
     if (this.email) {
       const user = await this.getUserByEmail();
@@ -63586,11 +63605,18 @@ class AppDatabase {
       "resistance",
       "symbol_config",
       "anchor",
-      "watch_instance"
+      "watch_instance",
+      "short_compound_strategy.tracking_account.account"
     ];
     return fields.join(", ");
   }
   async fetchCentralPositions(payload) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.fetchCentralPositions({
+        ...payload,
+        email: this.email
+      });
+    }
     const { asset: assetName, symbol, customFilter = "" } = payload;
     const pb = this.pb;
     let symbolFilter = assetName ? `symbol ~ "${assetName}"` : `symbol = "${symbol}"`;
@@ -63604,6 +63630,9 @@ class AppDatabase {
     return positionsWithAssetName;
   }
   async getPositions(options) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.getPositions(options);
+    }
     const { symbol, as_view = false, account, custom_filter } = options;
     let default_params = as_view ? {
       table: "positions_view",
@@ -63642,6 +63671,9 @@ class AppDatabase {
       account,
       symbol
     });
+    if (this.drizzlePb) {
+      return db_positions;
+    }
     const exchange_db_instance = await this.get_exchange_db_instance(account);
     const long_exists = db_positions.find((x) => x.kind === "long");
     const short_exists = db_positions.find((x) => x.kind === "short");
@@ -63664,9 +63696,15 @@ class AppDatabase {
     return db_positions;
   }
   async update_db_position(position, payload) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.update_db_position(position, payload);
+    }
     return await this.pb.collection("positions").update(position.id, payload);
   }
   async getSymbolConfigFromDB(symbol) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.getSymbolConfigFromDB(symbol);
+    }
     const item = await this.pb.collection("symbol_configs").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
     });
@@ -63676,6 +63714,9 @@ class AppDatabase {
     return null;
   }
   async getOrders(account, options) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.getOrders(account, options);
+    }
     const { symbol, kind } = options;
     const db_orders = await this.pb.collection("orders").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}" && kind="${kind}"`,
@@ -63742,20 +63783,99 @@ class AppDatabase {
     });
   }
   async deleteAndBulCreateAllOrders(payload) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.getOrders(payload.account, {
+        symbol: payload.symbol,
+        kind: "long"
+      });
+    }
     const { account, symbol, all_orders } = payload;
-    console.log(`Fetching existing DB orders for ${account.owner}/${account.exchange} - ${symbol} to delete...`);
-    let pocketbase_ids_to_delete = [];
+    console.log(`Fetching existing DB orders for ${account.owner}/${account.exchange} - ${symbol} for deduplication...`);
+    let existing_orders = [];
     try {
-      const db_orders_to_delete = await this.pb.collection("orders").getFullList({
+      existing_orders = await this.pb.collection("orders").getFullList({
         filter: `symbol:lower="${symbol.toLowerCase()}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}"`
       });
-      pocketbase_ids_to_delete = db_orders_to_delete.map((o) => o.id);
-      console.log(`Found ${pocketbase_ids_to_delete.length} existing DB orders to delete.`);
+      console.log(`Found ${existing_orders.length} existing DB orders.`);
     } catch (error) {
-      console.error("Error fetching DB orders for deletion:", error);
+      console.error("Error fetching existing DB orders:", error);
+      existing_orders = [];
+    }
+    const existing_signatures = new Set;
+    const existing_ids_to_delete = new Set;
+    for (const existing_order of existing_orders) {
+      const signature = [
+        existing_order.symbol?.toLowerCase() || "",
+        existing_order.kind || "",
+        existing_order.price?.toString() || "",
+        existing_order.quantity?.toString() || "",
+        existing_order.side?.toLowerCase() || "",
+        existing_order.stop?.toString() || "0",
+        existing_order.order_id?.toString() || "",
+        existing_order.client_order_id?.toString() || "",
+        account.id
+      ].join("|");
+      existing_signatures.add(signature);
+      existing_ids_to_delete.add(existing_order.id);
+    }
+    const unique_orders = [];
+    const new_signatures = new Set;
+    for (const order of all_orders) {
+      const signature = [
+        symbol.toLowerCase(),
+        order.kind || "",
+        order.price?.toString() || "",
+        order.quantity?.toString() || "",
+        order.side?.toLowerCase() || "",
+        (order.stop || order.triggerPrice || 0).toString(),
+        order.order_id?.toString() || "",
+        (order.clientOrderId || "").toString(),
+        account.id
+      ].join("|");
+      if (!existing_signatures.has(signature) && !new_signatures.has(signature)) {
+        unique_orders.push(order);
+        new_signatures.add(signature);
+      } else {
+        console.log(`Skipping duplicate order: ${order.order_id} for ${symbol}`);
+      }
+    }
+    console.log(`After deduplication: ${unique_orders.length} unique orders out of ${all_orders.length} total orders`);
+    const orders_to_keep = new Set;
+    for (const order of all_orders) {
+      const signature = [
+        symbol.toLowerCase(),
+        order.kind || "",
+        order.price?.toString() || "",
+        order.quantity?.toString() || "",
+        order.side?.toLowerCase() || "",
+        (order.stop || order.triggerPrice || 0).toString(),
+        order.order_id?.toString() || "",
+        (order.clientOrderId || "").toString(),
+        account.id
+      ].join("|");
+      if (existing_signatures.has(signature)) {
+        orders_to_keep.add(signature);
+      }
+    }
+    const pocketbase_ids_to_delete = [];
+    for (const existing_order of existing_orders) {
+      const signature = [
+        existing_order.symbol?.toLowerCase() || "",
+        existing_order.kind || "",
+        existing_order.price?.toString() || "",
+        existing_order.quantity?.toString() || "",
+        existing_order.side?.toLowerCase() || "",
+        existing_order.stop?.toString() || "0",
+        existing_order.order_id?.toString() || "",
+        existing_order.client_order_id?.toString() || "",
+        account.id
+      ].join("|");
+      if (!orders_to_keep.has(signature)) {
+        pocketbase_ids_to_delete.push(existing_order.id);
+      }
     }
     if (pocketbase_ids_to_delete.length > 0) {
-      console.log(`Deleting ${pocketbase_ids_to_delete.length} existing orders from PocketBase...`);
+      console.log(`Deleting ${pocketbase_ids_to_delete.length} obsolete orders from PocketBase...`);
       for (let i2 = 0;i2 < pocketbase_ids_to_delete.length; i2 += 5) {
         const batch_to_delete = pocketbase_ids_to_delete.slice(i2, i2 + 5);
         try {
@@ -63764,13 +63884,12 @@ class AppDatabase {
           console.error(`Error deleting batch starting at index ${i2}:`, error, "Batch IDs:", batch_to_delete);
         }
       }
-      console.log("Finished deleting existing DB orders.");
+      console.log("Finished deleting obsolete DB orders.");
     }
-    console.log(`Found ${all_orders.length} current orders on the exchange.`);
-    if (all_orders.length > 0) {
-      console.log(`Recreating ${all_orders.length} orders in PocketBase...`);
-      for (let i2 = 0;i2 < all_orders.length; i2 += 100) {
-        const orderChunk = all_orders.slice(i2, i2 + 100);
+    if (unique_orders.length > 0) {
+      console.log(`Creating ${unique_orders.length} new orders in PocketBase...`);
+      for (let i2 = 0;i2 < unique_orders.length; i2 += 100) {
+        const orderChunk = unique_orders.slice(i2, i2 + 100);
         const batch2 = this.pb.createBatch();
         for (const order of orderChunk) {
           const order_data = {
@@ -63792,8 +63911,9 @@ class AppDatabase {
           console.error(`Error creating batch starting at index ${i2}:`, error);
         }
       }
-      console.log("Finished recreating orders in PocketBase.");
+      console.log("Finished creating new orders in PocketBase.");
     }
+    console.log(`Order synchronization complete. Created ${unique_orders.length} new orders, deleted ${pocketbase_ids_to_delete.length} obsolete orders.`);
   }
   async cancelLimitOrders(payload) {
     const { symbol, kind, account, cancelExchangeOrders, raw } = payload;
@@ -63808,7 +63928,7 @@ class AppDatabase {
     const stop_limit_orders = await this.pb.collection("orders").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}" && kind="${kind}" && side:lower="${side}" && stop > 0`
     });
-    const exchange_order_ids = orders.concat(existing_stop_orders).concat(stop_limit_orders).map((o) => account.exchange === "bybit" ? o.order_id : account.exchange === "binance" && o.client_order_id ? o.client_order_id : parseInt(o.order_id, 10));
+    const exchange_order_ids = orders.concat(existing_stop_orders).concat(stop_limit_orders).map((o) => account.exchange === "bybit" ? o.order_id : ["binance", "paper"].includes(account.exchange) && o.client_order_id ? o.client_order_id : parseInt(o.order_id, 10));
     if (raw) {
       return exchange_order_ids;
     }
@@ -63882,6 +64002,9 @@ class AppDatabase {
     return result;
   }
   async updateScheduledTrade(id, payload) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.updateScheduledTrade(id, payload);
+    }
     return await this.pb.collection("scheduled_trades").update(id, payload);
   }
   async getPositionsToAutoFollow() {
@@ -64135,6 +64258,9 @@ class AppDatabase {
     return { updated_bullish, moved_to_winding };
   }
   async updateSymbolConfigs(payload) {
+    if (this.drizzlePb) {
+      return this.drizzlePb.updateSymbolConfigs(payload);
+    }
     if (!payload || !payload.configs) {
       console.log("No payload provided. Fetching all symbol configs...");
       try {
@@ -64452,8 +64578,7 @@ function getEntries(params) {
         margin_range,
         risk_reward,
         kind,
-        price_places,
-        percent_change: distribution_params?.curveFactor
+        price_places
       });
       break;
     case "normal":
@@ -64483,12 +64608,37 @@ function getEntries(params) {
         curveFactor: distribution_params?.curveFactor
       });
       break;
+    case "lognormal":
+      entries = generateLognormal({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        stdDevFactor: distribution_params?.stdDevFactor
+      });
+      break;
     default:
       throw new Error(`Unknown distribution type: ${distribution}`);
   }
   return entries.sort((a, b) => a - b);
 }
 var distributions_default = getEntries;
+function generateLognormal(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", stdDevFactor = 6 } = payload;
+  const logMin = Math.log(margin_range[0]);
+  const logMax = Math.log(margin_range[1]);
+  const mean = (logMin + logMax) / 2;
+  const stdDev = Math.abs(logMax - logMin) / stdDevFactor;
+  const entries = Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const p = (i2 + 0.5) / (risk_reward + 1);
+    const z2 = approximateInverseNormal(p);
+    let logPrice = mean + stdDev * z2;
+    logPrice = Math.max(logMin, Math.min(logMax, logPrice));
+    const price = Math.exp(logPrice);
+    return to_f(kind === "long" ? Math.min(price, margin_range[1]) : Math.max(price, margin_range[0]), price_places);
+  });
+  return entries.sort((a, b) => a - b);
+}
 
 // src/helpers/optimizations.ts
 function calculateTheoreticalKelly({
@@ -64862,7 +65012,7 @@ class Signal {
     const simple_support = Math.min(current_price, stop_loss);
     const simple_resistance = Math.max(current_price, stop_loss);
     const risk_per_trade = risk / this.risk_reward;
-    const use_progressive = distribution_params.use_progressive || this.use_progressive_risk;
+    const use_progressive = distribution_params?.use_progressive || this.use_progressive_risk;
     const risk_distribution = use_progressive ? {
       enabled: true,
       total_risk_budget: risk,
@@ -65331,7 +65481,6 @@ class Signal {
         const defaultStopLoss = i2 === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
         let risk_to_use = this.getZoneRisk(i2, limit_orders.length, this);
-        console.log("index: ", i2, " risk: ", risk_to_use);
         if (this.use_kelly) {
           const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
           const theoretical_kelly = func({
@@ -65575,6 +65724,9 @@ var pnl_default = value;
 
 // src/helpers/trade_utils.ts
 function to_f(value2, places = "%.1f") {
+  if (!value2) {
+    return null;
+  }
   let v = typeof value2 === "string" ? parseFloat(value2) : value2;
   const formattedValue = places.replace("%.", "").replace("f", "");
   return parseFloat(v.toFixed(parseInt(formattedValue)));
@@ -65805,7 +65957,7 @@ function buildConfig(app_config, {
   min_avg_size = 0,
   distribution,
   distribution_params,
-  use_progressive_risk
+  use_progressive_risk = false
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -65847,7 +65999,7 @@ function buildConfig(app_config, {
   if (!stop) {
     return [];
   }
-  const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
+  const condition = true;
   if (kind === "short") {}
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
@@ -66317,7 +66469,7 @@ function determineOptimumReward(payload) {
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
   let func = risk_rewards.map((trade_no) => {
-    let trades = sortedBuildConfig(app_config, {
+    const pp = {
       take_profit: app_config.take_profit,
       entry: app_config.entry,
       stop: app_config.stop,
@@ -66329,7 +66481,8 @@ function determineOptimumReward(payload) {
       decimal_places: app_config.decimal_places,
       distribution,
       distribution_params: payload.distribution_params
-    });
+    };
+    let trades = sortedBuildConfig(app_config, pp);
     let total = 0;
     let max = -Infinity;
     let min = Infinity;
@@ -66420,7 +66573,6 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
       return b.net_diff - a.net_diff;
     }
   });
-  console.log("found", sortedFound);
   if (defaultKey === "quantity") {
     return sortedFound[0].index;
   }
@@ -67527,10 +67679,14 @@ function helperFuncToBuildTrades({
   symbol_config,
   app_config_kind,
   appConfig,
-  force_exact_risk = true
+  force_exact_risk = true,
+  use_default = false
 }) {
   const risk = custom_b_config.risk * (custom_b_config.risk_factor || 1);
-  let result = getRiskReward({
+  let result = use_default ? {
+    risk,
+    risk_reward: custom_b_config.risk_reward
+  } : getRiskReward({
     entry: custom_b_config.entry,
     stop: custom_b_config.stop,
     risk,
@@ -67579,7 +67735,8 @@ function buildWithOptimumReward({
   config: config2,
   settings,
   global_config,
-  force_exact
+  force_exact,
+  use_default = false
 }) {
   const kind = config2.entry > config2.stop ? "long" : "short";
   let stop = settings.stop;
@@ -67593,7 +67750,8 @@ function buildWithOptimumReward({
     stop,
     risk,
     distribution,
-    distribution_params
+    distribution_params,
+    risk_reward: settings.risk_reward || config2?.risk_reward
   };
   const appConfig = constructAppConfig2({
     config: config2,
@@ -67604,7 +67762,8 @@ function buildWithOptimumReward({
     app_config_kind: kind,
     appConfig,
     symbol_config: global_config,
-    force_exact_risk: force_exact
+    force_exact_risk: force_exact,
+    use_default
   });
   const adjusted_size = summary.quantity;
   const symbol_config = global_config;
@@ -67954,6 +68113,7 @@ class BaseExchange {
       });
     }
   }
+  async placeSpotLimitOrders(_payload) {}
   async bulkPlaceLimitOrders(payload) {
     const {
       orders,
@@ -68540,8 +68700,25 @@ var ORDERS_PER_MINUTE = 2000;
 var ORDERS_PER_SECOND = Math.floor(ORDERS_PER_MINUTE / 60);
 var BATCH_SIZE = 5;
 var CANCEL_BATCH_SIZE = 10;
-async function createLimitPurchaseOrdersParallel(client, symbol, priceFormat, quantityFormat, orders, currentPrice, workingType = "last", realClose = false) {
+async function createLimitPurchaseOrdersParallel(client, symbol, priceFormat, quantityFormat, _orders, currentPrice, workingType = "last", realClose = false) {
   const workingTypeValue = workingType === "mark" ? "MARK_PRICE" : "CONTRACT_PRICE";
+  const orders = _orders.map((u) => {
+    if (currentPrice && !u.stop) {
+      if (u.kind === "long" && u.price > currentPrice && u.side === "buy") {
+        return {
+          ...u,
+          force_market: true
+        };
+      }
+      if (u.kind === "short" && u.price < currentPrice && u.side === "sell") {
+        return {
+          ...u,
+          force_market: true
+        };
+      }
+    }
+    return u;
+  });
   const splitOrders = (inputOrders) => {
     const result = [];
     for (const o of inputOrders) {
@@ -68624,6 +68801,137 @@ async function createLimitPurchaseOrdersParallel(client, symbol, priceFormat, qu
   })));
   return results;
 }
+async function createSpotLimitOrdersParallel(client, symbol, priceFormat, quantityFormat, orders, currentPrice) {
+  const createSpotOrder = (x) => {
+    const v = {
+      symbol: symbol.toUpperCase(),
+      price: x.price ? to_f(x.price, priceFormat) : undefined,
+      quantity: x.quantity ? to_f(x.quantity, quantityFormat) : 0,
+      side: x.side?.toUpperCase() || "",
+      type: "LIMIT",
+      timeInForce: "GTC"
+    };
+    if (x.stop && x.stop > 0) {
+      v.type = "STOP_LOSS_LIMIT";
+      v.stopPrice = to_f(x.stop, priceFormat);
+      v.timeInForce = "GTC";
+    }
+    if (x.force_market || x.is_market) {
+      delete v.price;
+      delete v.timeInForce;
+      v.type = "MARKET";
+    }
+    if (x.timeInForce) {
+      v.timeInForce = x.timeInForce;
+    }
+    return v;
+  };
+  const newOrders = orders.map(createSpotOrder);
+  const batches = [];
+  for (let i2 = 0;i2 < newOrders.length; i2 += BATCH_SIZE) {
+    batches.push(newOrders.slice(i2, i2 + BATCH_SIZE));
+  }
+  const limit = import_p_limit.default(ORDERS_PER_SECOND);
+  const results = await Promise.all(batches.map((batch2) => limit(async () => {
+    try {
+      const batchResults = await Promise.all(batch2.map(async (orderPayload) => {
+        const cleanPayload = Object.fromEntries(Object.entries(orderPayload).filter(([, value2]) => value2 !== undefined));
+        return await client.submitNewOrder(cleanPayload);
+      }));
+      console.log("Spot batch result:", batchResults);
+      return batchResults;
+    } catch (error) {
+      console.error("Error processing spot batch:", error);
+      throw error;
+    }
+  })));
+  return results.flat();
+}
+async function placeSpotLimitOrders(client, payload) {
+  const { price_places = "%.8f", decimal_places = "%.8f", symbol } = payload;
+  if (payload.cancel) {
+    await cancelSpotOrders(client, symbol);
+  }
+  if (payload.orders && payload.orders.length > 0) {
+    const orders = payload.orders.map((x) => ({
+      side: x.side,
+      price: x.price,
+      quantity: x.quantity
+    }));
+    return await createSpotLimitOrdersParallel(client, symbol, price_places, decimal_places, orders);
+  }
+}
+async function cancelSpotOrders(client, symbol, orders) {
+  if (orders && orders.length > 0) {
+    for (const order of orders) {
+      try {
+        if (order.orderId) {
+          await client.cancelOrder({
+            symbol,
+            orderId: order.orderId
+          });
+        } else if (order.origClientOrderId) {
+          await client.cancelOrder({
+            symbol,
+            origClientOrderId: order.origClientOrderId
+          });
+        }
+      } catch (error) {
+        console.error("Error cancelling spot order:", error);
+      }
+    }
+  } else {
+    try {
+      const openOrders = await client.getOpenOrders({ symbol });
+      for (const order of openOrders) {
+        await client.cancelOrder({
+          symbol,
+          orderId: order.orderId
+        });
+      }
+    } catch (error) {
+      console.error("Error cancelling all spot orders:", error);
+    }
+  }
+}
+async function getSpotOpenOrders(client, symbol) {
+  try {
+    const response = await client.getOpenOrders({
+      symbol
+    });
+    return (response || []).map((order) => ({
+      ...order,
+      id: order.orderId,
+      order_id: order.orderId,
+      price: parseFloat(order.price),
+      quantity: parseFloat(order.origQty),
+      side: order.side.toLowerCase(),
+      type: order.type.toLowerCase(),
+      status: order.status.toLowerCase()
+    }));
+  } catch (error) {
+    console.error("Error fetching spot open orders:", error);
+    return [];
+  }
+}
+async function getSpotBalances(client, assets) {
+  try {
+    const response = await client.getAccountInformation();
+    let balances = response.balances.map((balance) => ({
+      asset: balance.asset,
+      free: parseFloat(balance.free),
+      locked: parseFloat(balance.locked),
+      total: parseFloat(balance.free) + parseFloat(balance.locked)
+    }));
+    if (assets && assets.length > 0) {
+      balances = balances.filter((balance) => assets.some((asset) => asset.toUpperCase() === balance.asset.toUpperCase()));
+    }
+    return balances.filter((balance) => balance.total > 0);
+  } catch (error) {
+    console.error("Error fetching spot balances:", error);
+    return [];
+  }
+}
 async function getPositionInfo(client, symbol) {
   const response = await client.getPositionsV3({
     symbol
@@ -69140,7 +69448,8 @@ class BinanceExchange extends BaseExchange {
     return await cancelAllOrders(this.client, symbol, payload);
   }
   async _createLimitPurchaseOrders(payload) {
-    return await createLimitPurchaseOrdersParallel(this.client, payload.symbol, payload.price_places, payload.decimal_places, payload.orders);
+    const current_price = await this.getCurrentPrice(payload.symbol);
+    return await createLimitPurchaseOrdersParallel(this.client, payload.symbol, payload.price_places, payload.decimal_places, payload.orders, current_price);
   }
   async analyzeCharts(payload) {
     return await analyzeCharts({
@@ -69475,6 +69784,51 @@ class BinanceExchange extends BaseExchange {
       };
     }
   }
+  async createSpotLimitOrders(payload) {
+    if (!this.main_client) {
+      throw new Error("Main client not available for spot trading");
+    }
+    return await createSpotLimitOrdersParallel(this.main_client, payload.symbol, payload.price_places || "%.8f", payload.decimal_places || "%.8f", payload.orders);
+  }
+  async placeSpotLimitOrders(payload) {
+    if (!this.main_client) {
+      throw new Error("Main client not available for spot trading");
+    }
+    return await placeSpotLimitOrders(this.main_client, payload);
+  }
+  async cancelSpotOrders(symbol, orders) {
+    if (!this.main_client) {
+      throw new Error("Main client not available for spot trading");
+    }
+    return await cancelSpotOrders(this.main_client, symbol, orders);
+  }
+  async getSpotOpenOrders(symbol) {
+    if (!this.main_client) {
+      throw new Error("Main client not available for spot trading");
+    }
+    return await getSpotOpenOrders(this.main_client, symbol);
+  }
+  async getSpotBalances(assets) {
+    if (!this.main_client) {
+      throw new Error("Main client not available for spot trading");
+    }
+    return await getSpotBalances(this.main_client, assets);
+  }
+  async getSpotCurrentPrice(symbol) {
+    if (!this.main_client) {
+      throw new Error("Main client not available for spot trading");
+    }
+    try {
+      const response = await this.main_client.getSymbolPriceTicker({
+        symbol: symbol.toUpperCase()
+      });
+      const price = Array.isArray(response) ? response[0]?.price : response.price;
+      return parseFloat(price);
+    } catch (error) {
+      console.error("Error fetching spot current price:", error);
+      throw error;
+    }
+  }
 }
 function getPricePlaces(target) {
   const numStr = target.toString();
@@ -70813,7 +71167,7 @@ class ExchangePosition {
     return compound_instance;
   }
   async getProxyForAccount() {
-    if (this.instance.expand.proxy) {
+    if (this.instance?.expand?.proxy) {
       const result = this.instance.expand.proxy;
       const { type, ip_address } = result;
       console.log("exchange", {
@@ -70882,11 +71236,21 @@ class ExchangePosition {
     if (this.instance.expand?.b_config) {
       return this.instance.expand.b_config;
     }
-    return await this.app_db.getPositionConfig({
+    const result = await this.app_db.getPositionConfig({
       symbol: this.symbol,
       kind: this.kind,
       account: this.account
     });
+    if (!result) {
+      const entry = this.kind === "long" ? this.symbol_config.resistance : this.symbol_config.support;
+      const stop = this.kind === "long" ? this.symbol_config.support : this.symbol_config.resistance;
+      const params = {
+        entry,
+        stop
+      };
+      return this.getConfig({ params });
+    }
+    return result;
   }
   async updateTargetPnl() {
     const position2 = this.instance;
@@ -70967,7 +71331,6 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func,
       distribution: payload.distribution || config2.distribution,
       distribution_params: payload.distribution_params || config2.distribution_params
     });
@@ -70985,7 +71348,6 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func,
       distribution: config2.distribution,
       distribution_params: payload.distribution_params || config2.distribution_params
     }, false);
@@ -71550,8 +71912,8 @@ class ExchangePosition {
       stop,
       risk_reward,
       risk,
-      distribution: db_config.distribution,
-      distribution_params: db_config.distribution_params
+      distribution: db_config?.distribution,
+      distribution_params: db_config?.distribution_params
     });
     let config2 = generate_config_params(app_config, {
       entry,
@@ -71663,19 +72025,21 @@ class ExchangePosition {
   async buildTrades(payload) {
     const { risk, use_progressive_risk } = payload;
     const config2 = await this.getConfig();
+    const entry = this.kind === "long" ? payload.resistance : payload.support;
+    const stop = this.kind === "long" ? payload.support : payload.resistance;
     const app_config = await this.buildAppConfig({
-      entry: config2.entry,
-      stop: config2.stop,
-      risk_reward: config2.risk_reward,
+      entry: entry || config2.entry,
+      stop: stop || config2.stop,
+      risk_reward: payload.risk_reward || config2.risk_reward,
       risk: risk || config2.risk,
       distribution: config2.distribution,
       distribution_params: config2.distribution_params,
       use_progressive_risk
     });
     const { trades } = await this.placeConfigOrders(app_config, {
-      risk_reward: config2.risk_reward,
-      entry: config2.entry,
-      stop: config2.stop,
+      risk_reward: payload.risk_reward || config2.risk_reward,
+      entry: entry || config2.entry,
+      stop: stop || config2.stop,
       risk_per_trade: risk || config2.risk,
       avg_size: 0,
       neg_pnl: 0,
@@ -71684,7 +72048,6 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func,
       distribution: config2.distribution,
       distribution_params: config2.distribution_params,
       use_progressive_risk
@@ -71718,9 +72081,11 @@ class ExchangePosition {
   async tradeConfig(payload) {
     const { override = {} } = payload;
     const config2 = await this.getConfig();
+    const entry = this.kind === "long" ? payload.resistance : payload.support;
+    const stop = this.kind === "long" ? payload.support : payload.resistance;
     const app_config = await this.buildAppConfig({
-      entry: config2.entry,
-      stop: config2.stop,
+      entry: entry || config2.entry,
+      stop: stop || config2.stop,
       risk_reward: config2.risk_reward,
       risk: config2.risk,
       symbol: this.symbol,
@@ -71728,7 +72093,6 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func,
       distribution: config2.distribution,
       distribution_params: config2.distribution_params,
       ...override
@@ -71766,8 +72130,9 @@ class ExchangePosition {
       ratio: payload.ratio
     });
   }
-  async getOptimumRiskReward() {
-    const app_config = await this.tradeConfig({});
+  async getOptimumRiskReward(payload) {
+    const app_config = await this.tradeConfig(payload || {});
+    console.log("app_config", app_config);
     const risk_reward = computeRiskReward({
       app_config,
       entry: app_config.entry,
@@ -71943,68 +72308,1549 @@ function convert_to_exchange_order(order) {
   };
 }
 
-// src/exchange-account.ts
-class ExchangeAccount {
-  instance;
-  exchange;
-  main_exchange;
-  app_db;
-  long_position;
-  short_position;
-  raw_positions;
-  constructor(payload, options) {
-    this.instance = payload;
-    this.exchange = options.exchange;
-    this.app_db = options.app_db;
-    this.main_exchange = options.main_exchange;
-  }
-  getDBInstance() {
-    return this.app_db;
+// src/exchanges/paper/index.ts
+var import_https_proxy_agent3 = __toESM(require_dist2());
+var import_socks_proxy_agent3 = __toESM(require_dist3());
+
+// src/exchanges/paper/engine-class.ts
+function generateSummary2({
+  trades = [],
+  fee_percent = 0.05,
+  anchor
+}) {
+  if (trades.length === 0) {
+    return {};
   }
-  async getLiveExchangeInstance(payload) {
-    const symbol_config = await this.recomputeSymbolConfig({
-      symbol: payload.symbol,
-      refresh: payload.refresh_symbol_config
-    });
-    const result = await this.app_db.getLiveExchangeInstance({
-      account: this.instance,
-      symbol: payload.symbol
-    });
-    if (payload.refresh || !result) {
-      const data = await this.exchange.getExchangeAccountInfo({
-        account: this.instance,
-        symbol: payload.symbol,
-        price_places: symbol_config?.price_places,
-        decimal_places: symbol_config?.decimal_places
-      });
-      if (symbol_config?.price_places) {
-        data.config.price_places = symbol_config.price_places;
-      }
-      if (symbol_config?.decimal_places) {
-        data.config.decimal_places = symbol_config.decimal_places;
-      }
-      return await this.app_db.createOrUpdateLiveExchangeInstance({
-        account: this.instance,
-        symbol: payload.symbol,
-        data
-      });
+  const avg_entry = trades[0].avg_entry;
+  const avg_size = trades[0].avg_size;
+  const expected_fee = avg_entry * avg_size * fee_percent / 100;
+  return {
+    first_entry: trades.at(-1).entry,
+    last_entry: trades[0].entry,
+    quantity: avg_size,
+    entry: avg_entry,
+    loss: trades[0].neg_pnl,
+    number_of_trades: trades.length,
+    fee: to_f(expected_fee, "%.2f"),
+    anchor_pnl: anchor?.target_pnl
+  };
+}
+function cumulativeHelper({
+  tradesList,
+  pos = {
+    quantity: 0,
+    entry: 0
+  },
+  decimal_places = "%.3f"
+}) {
+  let cumulativeQty = pos.quantity || 0;
+  const reversedTrades = [...tradesList].reverse();
+  const processedTrades = reversedTrades.map((trade) => {
+    cumulativeQty += trade.quantity;
+    const avg_size = to_f(cumulativeQty, decimal_places);
+    return {
+      ...trade,
+      cumulative_size: avg_size
+    };
+  });
+  return processedTrades.reverse();
+}
+
+class PositionState {
+  position;
+  trades;
+  take_profit = null;
+  stop_loss = null;
+  entry_fees;
+  fee_percent;
+  global_config;
+  constructor({
+    position: position2,
+    trades,
+    fee_percent = 0,
+    entry_fees = 0,
+    global_config
+  }) {
+    this.position = position2;
+    this.trades = trades ?? [];
+    this.entry_fees = entry_fees ?? 0;
+    this.fee_percent = fee_percent ?? 0;
+    this.global_config = global_config;
+  }
+  get newTrades() {
+    const tradesList = this.trades;
+    const pos = this.position;
+    if (!tradesList || tradesList.length === 0) {
+      return [];
     }
-    return result;
-  }
-  async initializePositions(payload) {
-    const raw_positions = await this.syncAccount({
-      update: payload.update,
-      symbol: payload.symbol,
-      live_refresh: payload.update
+    let cumulativeQty = pos.quantity || 0;
+    let cumulativeValue = cumulativeQty * (pos.entry || 0);
+    const reversedTrades = [...tradesList].reverse();
+    const processedTrades = reversedTrades.map((trade) => {
+      cumulativeQty += trade.quantity;
+      cumulativeValue += trade.quantity * trade.entry;
+      const avg_entry = cumulativeQty > 0 ? to_f(cumulativeValue / cumulativeQty, this.global_config.price_places) : 0;
+      const avg_size = to_f(cumulativeQty, this.global_config.decimal_places);
+      const stop = trade.stop || pos.kind === "long" ? Math.min(...tradesList.map((o) => o.entry)) : Math.max(...tradesList.map((o) => o.entry));
+      const neg_pnl = to_f(Math.abs(avg_entry - stop) * avg_size, this.global_config.price_places);
+      return {
+        ...trade,
+        avg_entry,
+        avg_size,
+        neg_pnl
+      };
     });
-    const positions = await this.syncAccount({
-      symbol: payload.symbol,
-      as_view: true
+    return processedTrades.reverse();
+  }
+  generateSummary(fee_percentOverride) {
+    const trades = this.newTrades;
+    const fee_percent = fee_percentOverride ?? this.fee_percent;
+    return {
+      ...generateSummary2({
+        trades,
+        fee_percent
+      }),
+      entry_fees: to_f(this.entry_fees, "%.2f")
+    };
+  }
+  get summary() {
+    return this.generateSummary();
+  }
+  positionAt(price) {
+    const trades = this.newTrades;
+    const kind = this.position.kind;
+    const filtered = trades.filter((trade) => {
+      if (kind === "long") {
+        return trade.entry >= price;
+      }
+      return trade.entry <= price;
+    });
+    return filtered[0];
+  }
+  newPositionState(price) {
+    const position2 = this.position;
+    const trades = this.newTrades;
+    const instance = this.positionAt(price);
+    if (!instance) {
+      return new PositionState({
+        position: { ...position2 },
+        trades,
+        fee_percent: this.fee_percent,
+        entry_fees: this.entry_fees,
+        global_config: this.global_config
+      });
+    }
+    return new PositionState({
+      position: {
+        ...position2,
+        entry: instance.avg_entry,
+        quantity: instance.avg_size
+      },
+      trades,
+      fee_percent: this.fee_percent,
+      entry_fees: this.entry_fees,
+      global_config: this.global_config
+    });
+  }
+  updateTakeProfit({ entry, quantity }) {
+    this.take_profit = {
+      price: entry,
+      quantity: quantity ?? this.position.quantity
+    };
+  }
+  updateStopLoss(payload) {
+    const { stop, quantity } = payload ?? {
+      stop: this.newTrades[0].entry,
+      quantity: this.summary.quantity
+    };
+    this.stop_loss = {
+      price: stop,
+      quantity
+    };
+  }
+}
+function determineNewPosition({
+  position: position2,
+  price,
+  trades,
+  global_config
+}) {
+  const kind = position2.kind;
+  const placed = trades.filter((t2) => {
+    let _price = t2.entry || t2.price;
+    let condition1 = kind === "long" ? _price >= price : _price <= price;
+    return condition1;
+  }).map((t2) => {
+    let _price = t2.entry || t2.price;
+    let condition2 = kind === "long" ? _price >= position2.entry : _price <= position2.entry;
+    if (condition2) {
+      return {
+        ...t2,
+        price: position2.entry,
+        entry: position2.entry
+      };
+    }
+    return t2;
+  });
+  const placeQty = placed.reduce((acc, trade) => acc + trade.quantity, 0);
+  if (position2.quantity > 0) {
+    const placed_less_than_entry = placed.filter((t2) => {
+      let condition1 = kind === "long" ? t2.entry <= position2.entry : t2.entry >= position2.entry;
+      return condition1;
+    });
+    const avg = determine_average_entry_and_size(placed_less_than_entry.map((o) => ({
+      price: o.entry || o.price,
+      quantity: o.quantity
+    })).concat([{ price: position2.entry, quantity: position2.quantity }]), global_config.decimal_places, global_config.price_places);
+    position2.entry = avg.price;
+    position2.quantity = avg.quantity;
+    return position2;
+  }
+  return {
+    ...position2,
+    entry: price,
+    quantity: placeQty
+  };
+}
+function positionAt({
+  price,
+  position: position2,
+  trades = [],
+  as_state = true,
+  global_config
+}) {
+  const kind = position2.kind;
+  const fee_rate = {
+    maker: 0.02,
+    taker: 0.05
+  };
+  const placed = trades.filter((t2) => {
+    let _price = t2.entry || t2.price;
+    let condition1 = kind === "long" ? _price >= price : _price <= price;
+    return condition1;
+  });
+  const not_placed = trades.filter((t2) => {
+    let _price = t2.entry || t2.price;
+    let condition1 = kind === "long" ? _price < price : _price > price;
+    return condition1;
+  });
+  const placeQty = placed.reduce((acc, trade) => acc + trade.quantity, 0);
+  const takerFee = price * placeQty * fee_rate.taker / 100;
+  const makerFee = not_placed.reduce((acc, trade) => acc + trade.entry * trade.quantity * fee_rate.maker / 100, 0);
+  const fee = to_f(takerFee + makerFee, "%.2f");
+  const result = {
+    trades: not_placed,
+    position: determineNewPosition({
+      global_config,
+      position: { ...position2, kind },
+      price,
+      trades
+    }),
+    entry_fees: fee,
+    fee_percent: fee_rate.maker,
+    global_config
+  };
+  if (as_state) {
+    const derivedState = new PositionState({
+      position: result.position,
+      trades: result.trades,
+      fee_percent: result.fee_percent,
+      entry_fees: parseFloat(result.entry_fees) || 0,
+      global_config
+    });
+    return derivedState;
+  }
+  return result;
+}
+
+class TradeEngine {
+  trade_details = null;
+  position;
+  global_config;
+  constructor({
+    global_config,
+    position: position2 = { entry: 0, quantity: 0, kind: "long" }
+  }) {
+    this.global_config = global_config;
+    this.position = position2;
+  }
+  generateShortTrades(config2) {
+    const result = compoundAPI.buildWithOptimumReward({
+      global_config: this.global_config,
+      config: config2,
+      settings: config2,
+      use_default: true
+    });
+    this.trade_details = result;
+  }
+  positionAt({
+    price,
+    dangerous,
+    trades: existingTrades
+  }) {
+    const trades = existingTrades || this.trade_details?.trades || [];
+    if (dangerous) {
+      const kind = this.position.kind;
+      const naive_assumptions = positionAt({
+        price,
+        position: {
+          kind,
+          entry: 0,
+          quantity: 0
+        },
+        global_config: this.global_config,
+        trades,
+        as_state: false
+      });
+      const avg_position = determine_average_entry_and_size([
+        {
+          price: this.position.entry,
+          quantity: this.position.quantity
+        },
+        {
+          price: naive_assumptions.position.entry,
+          quantity: naive_assumptions.position.quantity
+        }
+      ], this.global_config.decimal_places, this.global_config.price_places);
+      const new_position = dangerous ? {
+        ...this.position,
+        entry: avg_position.entry,
+        quantity: avg_position.quantity
+      } : this.position;
+      return new PositionState({
+        ...naive_assumptions,
+        trades: naive_assumptions.trades,
+        position: new_position,
+        global_config: this.global_config
+      });
+    }
+    const _trades = cumulativeHelper({
+      tradesList: [...trades].concat({
+        entry: this.position.entry,
+        quantity: this.position.quantity
+      }),
+      decimal_places: this.global_config.decimal_places
+    }).filter((o) => {
+      const numeric = Number(o.cumulative_size);
+      return numeric > this.position.quantity;
+    });
+    return positionAt({
+      price,
+      position: this.position,
+      trades: _trades,
+      global_config: this.global_config
+    });
+  }
+  initializeEngine({
+    price,
+    dangerous,
+    trades,
+    config: config2
+  }) {
+    if (config2) {
+      this.generateShortTrades(config2);
+    }
+    return this.positionAt({
+      price,
+      dangerous,
+      trades
+    });
+  }
+}
+function transformTradesToExchangeType({
+  trades,
+  take_profit,
+  stop_loss,
+  kind
+}) {
+  const currentTime = Date.now();
+  const result = [];
+  trades.forEach((trade, index) => {
+    const side = kind === "long" ? "buy" : "sell";
+    const positionSide = kind.toUpperCase();
+    result.push({
+      avgPrice: "0",
+      clientOrderId: `${index}-${kind}-${side}`.toString(),
+      closePosition: false,
+      cumQuote: "0.0000",
+      executedQty: 0,
+      goodTillDate: 0,
+      id: index,
+      isStop: false,
+      kind,
+      orderId: index,
+      order_id: index,
+      order_type: "future",
+      origQty: trade.quantity,
+      origType: "LIMIT",
+      positionSide,
+      price: trade.entry,
+      priceMatch: "NONE",
+      priceProtect: false,
+      qty: trade.quantity,
+      quantity: trade.quantity,
+      reduceOnly: false,
+      selfTradePreventionMode: "EXPIRE_MAKER",
+      side,
+      status: "NEW",
+      stop: trade.stop || 0,
+      stopPrice: 0,
+      symbol: undefined,
+      time: currentTime,
+      timeInForce: "GTC",
+      triggerPrice: 0,
+      type: "LIMIT",
+      updateTime: currentTime,
+      workingType: "CONTRACT_PRICE"
+    });
+  });
+  let nextOrderId = trades.length;
+  if (take_profit && take_profit.quantity > 0) {
+    const tpSide = kind === "long" ? "sell" : "buy";
+    const tpPositionSide = kind.toUpperCase();
+    result.push({
+      avgPrice: "0",
+      clientOrderId: `tp_${nextOrderId}`,
+      closePosition: false,
+      cumQuote: "0.0000",
+      executedQty: 0,
+      goodTillDate: 0,
+      id: nextOrderId,
+      isStop: false,
+      kind,
+      orderId: nextOrderId,
+      order_id: nextOrderId,
+      order_type: "future",
+      origQty: take_profit.quantity,
+      origType: "LIMIT",
+      positionSide: tpPositionSide,
+      price: take_profit.price,
+      priceMatch: "NONE",
+      priceProtect: false,
+      qty: take_profit.quantity,
+      quantity: take_profit.quantity,
+      reduceOnly: true,
+      selfTradePreventionMode: "EXPIRE_MAKER",
+      side: tpSide,
+      status: "NEW",
+      stop: 0,
+      stopPrice: 0,
+      symbol: undefined,
+      time: currentTime,
+      timeInForce: "GTC",
+      triggerPrice: 0,
+      type: "LIMIT",
+      updateTime: currentTime,
+      workingType: "CONTRACT_PRICE"
+    });
+    nextOrderId++;
+  }
+  if (stop_loss && stop_loss.quantity > 0) {
+    const slSide = kind === "long" ? "sell" : "buy";
+    const slPositionSide = kind.toUpperCase();
+    result.push({
+      avgPrice: "0",
+      clientOrderId: `sl_${nextOrderId}`,
+      closePosition: false,
+      cumQuote: "0.0000",
+      executedQty: 0,
+      goodTillDate: 0,
+      id: nextOrderId,
+      isStop: true,
+      kind,
+      orderId: nextOrderId,
+      order_id: nextOrderId,
+      order_type: "future",
+      origQty: stop_loss.quantity,
+      origType: "LIMIT",
+      positionSide: slPositionSide,
+      price: stop_loss.price,
+      priceMatch: "NONE",
+      priceProtect: false,
+      qty: stop_loss.quantity,
+      quantity: stop_loss.quantity,
+      reduceOnly: true,
+      selfTradePreventionMode: "EXPIRE_MAKER",
+      side: slSide,
+      status: "NEW",
+      stop: stop_loss.price,
+      stopPrice: stop_loss.price,
+      symbol: undefined,
+      time: currentTime,
+      timeInForce: "GTC",
+      triggerPrice: stop_loss.price,
+      type: "LIMIT",
+      updateTime: currentTime,
+      workingType: "CONTRACT_PRICE"
+    });
+  }
+  return result;
+}
+function isStopLossOrder(order) {
+  return order.kind === "long" && order.side === "sell" && order.stop > 0 || order.kind === "short" && order.side === "buy" && order.stop > 0;
+}
+function isTakeProfitOrder(order) {
+  return order.kind === "long" && order.side === "sell" && order.stop === 0 || order.kind === "short" && order.side === "buy" && order.stop === 0;
+}
+function transformExchangeOrderToTradeWithValidation(orders, options) {
+  const {
+    validatePrice = true,
+    validateQuantity = true,
+    defaultStop = 0
+  } = options || {};
+  const trades = [];
+  let take_profit;
+  let stop_loss;
+  orders.forEach((order, index) => {
+    if (validatePrice && (typeof order.price !== "number" || order.price <= 0)) {
+      throw new Error(`Invalid price at index ${index}: ${order.price}. Price must be a positive number`);
+    }
+    if (validateQuantity && (typeof order.quantity !== "number" || order.quantity <= 0)) {
+      throw new Error(`Invalid quantity at index ${index}: ${order.quantity}. Quantity must be a positive number`);
+    }
+    if (order.status !== "NEW") {
+      console.warn(`Order at index ${index} has status "${order.status}" - may not be suitable for trade conversion`);
+    }
+    if (isTakeProfitOrder(order) && !take_profit) {
+      take_profit = {
+        price: order.price,
+        quantity: order.quantity
+      };
+      return;
+    }
+    if (isStopLossOrder(order) && !stop_loss) {
+      stop_loss = {
+        price: order.price,
+        quantity: order.quantity
+      };
+      return;
+    }
+    trades.push({
+      entry: order.price,
+      quantity: order.quantity,
+      avg_size: order.quantity,
+      neg_pnl: 0,
+      avg_entry: order.price,
+      stop: stop_loss?.price || order.stop || defaultStop,
+      reverse_avg_entry: order.price,
+      reverse_avg_quantity: order.quantity,
+      fee: 0,
+      sell_price: undefined
+    });
+  });
+  return {
+    trades,
+    take_profit,
+    stop_loss
+  };
+}
+function updatePositionBasedOffTpOrSl({
+  kind,
+  orders,
+  positions,
+  current_price
+}) {
+  const position2 = positions[kind];
+  const side_orders = orders.filter((o) => o.positionSide.toLowerCase() === kind);
+  const { trades, take_profit, stop_loss } = transformExchangeOrderToTradeWithValidation(side_orders, {
+    validatePrice: false,
+    validateQuantity: false,
+    defaultStop: 0
+  });
+  if (position2.quantity === 0) {
+    return {
+      trades,
+      position: position2,
+      orders: side_orders,
+      changed: null
+    };
+  }
+  if (take_profit && take_profit.quantity) {
+    const should_close = kind === "long" ? current_price >= take_profit.price : current_price <= take_profit.price;
+    if (should_close) {
+      position2.quantity = Math.max(0, position2.quantity - take_profit.quantity);
+      if (position2.quantity === 0) {
+        position2.entry = 0;
+      }
+      return {
+        trades,
+        position: position2,
+        orders: transformTradesToExchangeType({
+          trades,
+          kind,
+          stop_loss
+        }),
+        changed: "tp"
+      };
+    }
+  }
+  if (stop_loss && stop_loss.quantity) {
+    const should_close = kind === "long" ? current_price <= stop_loss.price : current_price >= stop_loss.price;
+    if (should_close) {
+      position2.quantity = Math.max(0, position2.quantity - stop_loss.quantity);
+      if (position2.quantity === 0) {
+        position2.entry = 0;
+      }
+      return {
+        position: position2,
+        orders: transformTradesToExchangeType({
+          trades: trades.filter((t2) => kind === "long" ? t2.entry < stop_loss.price : t2.entry > stop_loss.price),
+          kind,
+          take_profit
+        }),
+        changed: "sl",
+        trades
+      };
+    }
+  }
+  return {
+    trades,
+    position: position2,
+    orders: side_orders,
+    changed: null
+  };
+}
+
+// src/exchanges/paper/index.ts
+async function initClient3(credentials, options) {
+  try {
+    const [account, exchange] = credentials.api_key.split(",");
+    const email = options.db?.email;
+    const password = options.db?.password;
+    async function initializeAppDb() {
+      const db = await initPocketBaseClient({
+        host: options.db?.host,
+        email,
+        password
+      });
+      const app_db2 = new AppDatabase(db, {
+        email: options.db?.email,
+        salt: undefined
+      });
+      return app_db2;
+    }
+    const app_db = await initializeAppDb();
+    const exchange_credentials = await app_db.getCredentials({
+      password
+    });
+    const account_detail = await app_db.get_exchange_db_instance({
+      owner: account,
+      exchange
+    });
+    const { type, ip_address } = account_detail.expand.proxy;
+    const proxyAgent = type === "http" ? new import_https_proxy_agent3.HttpsProxyAgent(`http://${ip_address}`) : new import_socks_proxy_agent3.SocksProxyAgent(`socks5://${ip_address}`);
+    const credential = exchange_credentials.find((c) => c.name === account && c.exchange === exchange);
+    if (!credential) {
+      throw new Error(`Missing API Key or Secret for account '${account}' in .env file. Please check your environment variables.`);
+    }
+    const clientFunc = initClient;
+    const client = await clientFunc(credential, {
+      type: "future",
+      proxyAgent
+    });
+    return {
+      client,
+      app_db,
+      initializeAppDb,
+      owner: account
+    };
+  } catch (e2) {
+    console.log(e2);
+  }
+}
+function buildPosition3(position2, orders, options) {
+  const { price_places = "%.1f", decimal_places = "%.3f" } = options;
+  const entry = position2.entryPrice;
+  let quantity = Math.abs(position2.positionAmt);
+  const kind = position2.kind;
+  if (Number.isNaN(quantity)) {
+    quantity = 0;
+  }
+  const limitOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((o) => {
+    return kind === "long" ? o.side === "buy" : o.side === "sell";
+  });
+  const avg = determine_average_entry_and_size([
+    { price: entry, quantity },
+    ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
+  ], decimal_places, price_places);
+  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
+  const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
+  const avg_entry = avg.entry;
+  const stop_loss = stopOrders?.triggerPrice || 0;
+  const take_profit = tpOrders?.price || 0;
+  const tp_quantity = tpOrders?.qty || 0;
+  const stop_quantity = stopOrders?.qty || 0;
+  return {
+    id: 0,
+    kind,
+    entry,
+    symbol: position2.symbol,
+    quantity,
+    avg_entry,
+    config_id: 0,
+    stop_loss,
+    take_profit,
+    tp_quantity,
+    stop_quantity,
+    liquidation: position2.liquidationPrice ? to_f(position2.liquidationPrice, price_places) : 0
+  };
+}
+var emptyPosition3 = {
+  id: 0,
+  kind: "long",
+  entry: 0,
+  symbol: "",
+  quantity: 0,
+  avg_entry: 0,
+  config_id: 0,
+  stop_loss: 0,
+  take_profit: 0,
+  tp_quantity: 0,
+  stop_quantity: 0
+};
+async function getOpenOrders3(client, symbol, type) {
+  const { orders } = await fetchDBExchangeData(client, symbol);
+  if (type === "tp") {
+    const tpOrders = orders.filter((x) => {
+      const isLong = x.positionSide.toLowerCase() === "long";
+      const isStop = x.stopPrice > 0;
+      if (isLong) {
+        return !isStop && x.side.toLowerCase() === "sell" && x.positionSide.toLowerCase() === "long";
+      } else {
+        return !isStop && x.side.toLowerCase() === "buy" && x.positionSide.toLowerCase() === "short";
+      }
+    });
+    return tpOrders.map((x) => ({
+      ...x,
+      price: x.price,
+      qty: x.origQty,
+      kind: x.positionSide.toLowerCase(),
+      side: x.side.toLowerCase(),
+      quantity: x.origQty
+    }));
+  }
+  if (type === "limit") {
+    const limitOrders = orders.filter((x) => {
+      const isLong = x.positionSide.toLowerCase() === "long";
+      const isStop = x.stopPrice > 0;
+      if (isLong) {
+        return !isStop && x.side.toLowerCase() === "buy" && x.positionSide.toLowerCase() === "long";
+      } else {
+        return !isStop && x.side.toLowerCase() === "sell" && x.positionSide.toLowerCase() === "short";
+      }
+    });
+    return limitOrders.map((x) => ({
+      ...x,
+      price: x.price,
+      qty: x.origQty,
+      kind: x.positionSide.toLowerCase(),
+      side: x.side.toLowerCase(),
+      quantity: x.origQty,
+      id: x.orderId,
+      order_id: x.orderId
+    }));
+  }
+  if (type === "stop") {
+    const stopOrders = orders.filter((x) => {
+      const isLong = x.positionSide.toLowerCase() === "long";
+      const isStop = x.stopPrice > 0;
+      if (isLong) {
+        return isStop && x.side.toLowerCase() === "sell" && x.positionSide.toLowerCase() === "long";
+      } else {
+        return isStop && x.side.toLowerCase() === "buy" && x.positionSide.toLowerCase() === "short";
+      }
+    });
+    return stopOrders.map((x) => ({
+      ...x,
+      price: x.price,
+      triggerPrice: x.stopPrice,
+      qty: x.origQty,
+      kind: x.positionSide.toLowerCase(),
+      side: x.side.toLowerCase(),
+      quantity: x.origQty
+    }));
+  }
+  return orders.map((x) => ({
+    ...x,
+    price: x.price,
+    qty: x.origQty,
+    kind: x.positionSide.toLowerCase(),
+    side: x.side.toLowerCase(),
+    isStop: x.stopPrice > 0,
+    order_type: "future",
+    quantity: x.origQty,
+    triggerPrice: x.stopPrice,
+    stop: x.stopPrice,
+    id: x.orderId,
+    order_id: x.orderId
+  }));
+}
+async function getWalletBalance3(client, asset = "USDT") {
+  const response = await client.getBalanceV3();
+  const balance = response.find((x) => x.asset.toLowerCase() === asset.toLowerCase())?.balance;
+  return balance ? to_f(balance, "%.2f") : 0;
+}
+async function allWalletBalances3(client) {
+  const response = await client.getBalanceV3();
+  return response.map((x) => ({
+    type: "future",
+    asset: x.asset,
+    balance: to_f(x.balance, "%.8f")
+  }));
+}
+async function getLeverage2(client, symbol) {
+  const response = await client.getPositions({
+    symbol
+  });
+  const leverage = response[0]?.leverage;
+  return leverage ? to_f(leverage, "%0f") : 0;
+}
+async function updateDbDetails(client, payload, current_account_info, new_payload) {
+  const position2 = payload.kind === "long" ? current_account_info.long_position : current_account_info.short_position;
+  const take_profit = new_payload.take_profit || (position2.tp_quantity > 0 ? {
+    price: position2.take_profit,
+    quantity: position2.tp_quantity
+  } : undefined);
+  const stop_loss = new_payload.stop_loss || (position2.stop_quantity > 0 ? {
+    price: position2.stop_loss,
+    quantity: position2.stop_quantity
+  } : undefined);
+  const as_exchange_orders = new_payload.raw ? new_payload.orders : transformTradesToExchangeType({
+    trades: new_payload.orders,
+    kind: payload.kind,
+    take_profit,
+    stop_loss
+  });
+  const reverse_kind = payload.kind === "long" ? "short" : "long";
+  const reverse_orders = current_account_info.config.trades.exchange_info.open_orders.filter((o) => {
+    return o.positionSide.toLowerCase() === reverse_kind;
+  });
+  current_account_info.config.trades.exchange_info.open_orders = as_exchange_orders.concat(reverse_orders);
+  current_account_info.config.trades.exchange_info.positions[payload.kind] = {
+    ...position2,
+    ...new_payload.position
+  };
+  const app_db = await client.initializeAppDb();
+  await app_db.createOrUpdateLiveExchangeInstance({
+    account: {
+      owner: client.owner,
+      exchange: "paper"
+    },
+    symbol: payload.symbol,
+    data: current_account_info
+  });
+  return current_account_info;
+}
+async function savePaperDetails(client, payload, new_payload) {
+  const current_account_info = await fetchBinanceAccount2(client, {
+    symbol: payload.symbol
+  }, {
+    price_places: payload.price_places,
+    decimal_places: payload.decimal_places
+  });
+  return await updateDbDetails(client, payload, current_account_info, new_payload);
+}
+async function fetchDBExchangeData(client, symbol) {
+  const current_price = await getCurrentPrice3(client.client, symbol);
+  let orders = [];
+  let trades = { long: [], short: [] };
+  let positions = {
+    long: null,
+    short: null
+  };
+  let config2 = {
+    long: null,
+    short: null
+  };
+  const app_db = await client.initializeAppDb();
+  const live_exchange_details = await app_db.getLiveExchangeInstance({
+    account: {
+      owner: client.owner,
+      exchange: "paper"
+    },
+    symbol
+  });
+  const symbol_config = await app_db.getSymbolConfigFromDB(symbol);
+  if (live_exchange_details) {
+    const raw_data = live_exchange_details.data;
+    orders = raw_data.config.trades.exchange_info.open_orders || [];
+    positions = raw_data.config.trades.exchange_info.positions;
+    const long_result = updatePositionBasedOffTpOrSl({
+      current_price,
+      orders,
+      positions,
+      kind: "long"
+    });
+    const short_result = updatePositionBasedOffTpOrSl({
+      current_price,
+      orders,
+      positions,
+      kind: "short"
+    });
+    orders = long_result.orders.concat(short_result.orders);
+    positions.long = long_result.position;
+    positions.short = short_result.position;
+    live_exchange_details.data.config.trades.exchange_info.open_orders = orders;
+    live_exchange_details.data.config.trades.exchange_info.positions = positions;
+    trades = {
+      long: long_result.trades,
+      short: short_result.trades
+    };
+  }
+  return {
+    orders,
+    symbol_config,
+    positions,
+    current_price,
+    config: config2,
+    trades,
+    raw_data: live_exchange_details?.data
+  };
+}
+async function getPositionInfo3(client, symbol) {
+  const { positions, symbol_config, current_price, raw_data, trades } = await fetchDBExchangeData(client, symbol);
+  const long_generator = new TradeEngine({
+    position: {
+      kind: "long",
+      entry: positions.long?.entry || 0,
+      quantity: positions.long?.quantity || 0
+    },
+    global_config: symbol_config
+  });
+  const short_generator = new TradeEngine({
+    position: {
+      kind: "short",
+      entry: positions.short?.entry || 0,
+      quantity: positions.short?.quantity || 0
+    },
+    global_config: symbol_config
+  });
+  const long_state = long_generator.initializeEngine({
+    trades: trades.long,
+    price: current_price
+  });
+  const short_state = short_generator.initializeEngine({
+    trades: trades.short,
+    price: current_price
+  });
+  if (raw_data) {
+    const long_state_trades = long_state.newTrades;
+    const short_state_trades = short_state.newTrades;
+    if (trades.long.length !== long_state_trades.length && positions.long.quantity !== long_state.position.quantity) {
+      console.log({
+        old: trades.long.length,
+        new: long_state_trades.length,
+        position: long_state.position
+      });
+      let _position = {
+        entry: long_state.position.entry,
+        quantity: long_state.position.quantity
+      };
+      let tp = undefined;
+      if (long_state_trades.length === 0 && positions.long.quantity === 0) {
+        _position.entry = 0;
+        _position.quantity = 0;
+        long_state.position.entry = 0;
+        long_state.position.quantity = 0;
+        tp = {
+          price: 0,
+          quantity: 0
+        };
+      }
+      await updateDbDetails(client, {
+        kind: "long",
+        symbol
+      }, raw_data, {
+        take_profit: tp,
+        position: _position,
+        orders: long_state_trades
+      });
+    }
+    if (trades.short.length !== short_state_trades.length && positions.short.quantity !== short_state.position.quantity) {
+      let _position = {
+        entry: short_state.position.entry,
+        quantity: short_state.position.quantity
+      };
+      let tp = undefined;
+      if (short_state_trades.length === 0 && positions.short.quantity === 0) {
+        _position.entry = 0;
+        _position.quantity = 0;
+        short_state.position.entry = 0;
+        short_state.position.quantity = 0;
+        tp = {
+          price: 0,
+          quantity: 0
+        };
+      }
+      await updateDbDetails(client, {
+        kind: "short",
+        symbol
+      }, raw_data, {
+        position: _position,
+        orders: short_state_trades,
+        take_profit: tp
+      });
+    }
+  }
+  const long_position = long_state.position;
+  const short_position = short_state.position;
+  const long_quantity = long_position.quantity;
+  const short_quantity = short_position.quantity;
+  const long = {
+    kind: "long",
+    size: long_quantity,
+    positionAmt: long_quantity,
+    entryPrice: long_quantity === 0 ? 0 : long_position.entry,
+    symbol
+  };
+  const short = {
+    kind: "short",
+    size: short_quantity,
+    positionAmt: short_quantity,
+    entryPrice: short_quantity === 0 ? 0 : short_position.entry,
+    symbol
+  };
+  return { long, short };
+}
+async function fetchBinanceAccount2(client, json, options) {
+  const [position2, balance, current_price, all_balances, leverage] = await Promise.all([
+    getPositionInfo3(client, json.symbol),
+    getWalletBalance3(client.client, json.symbol.toLowerCase().endsWith("usdt") ? "USDT" : "USDC"),
+    getCurrentPrice3(client.client, json.symbol),
+    allWalletBalances3(client.client),
+    getLeverage2(client.client, json.symbol)
+  ]);
+  const orders = await getOpenOrders3(client, json.symbol);
+  const limitOrders = orders.filter((x) => !x.isStop).filter((o) => {
+    return o.kind === "long" ? o.side === "buy" : o.side === "sell";
+  });
+  const stopOrders = orders.filter((x) => x.isStop);
+  const long_position = buildPosition3(position2.long || {
+    ...emptyPosition3,
+    kind: "long"
+  }, orders, options);
+  const short_position = buildPosition3(position2.short || {
+    ...emptyPosition3,
+    kind: "short"
+  }, orders, options);
+  const result = {
+    id: `${client.owner}-${json.symbol}-paper`,
+    owner: client.owner,
+    config: {
+      symbol: json.symbol,
+      id: 0,
+      price_places: options.price_places,
+      decimal_places: options.decimal_places,
+      trades: {}
+    },
+    exchange: "paper",
+    settings: {
+      default_take_profit: 0,
+      stop_buying: false
+    },
+    balance,
+    long_position,
+    short_position,
+    current_price,
+    orders: limitOrders,
+    entries: [],
+    stop_orders: stopOrders,
+    symbol: json.symbol,
+    leverage
+  };
+  result.config.trades = {
+    exchange_info: {
+      positions: {
+        both: null,
+        long: long_position,
+        short: short_position
+      },
+      account_balances: all_balances,
+      open_orders: orders
+    }
+  };
+  return result;
+}
+async function getCurrentPrice3(client, symbol) {
+  const response = await client.getSymbolPriceTickerV2({
+    symbol
+  });
+  return response.price;
+}
+async function placeStopOrder3(client, payload) {
+  const {
+    price_places = "%.1f",
+    decimal_places = "%.3f",
+    symbol,
+    current_price,
+    kind,
+    stop,
+    quantity,
+    cancel
+  } = payload;
+  if (kind === "long" && current_price < stop || kind === "short" && current_price > stop) {
+    console.log(`Diverting to TP order for ${symbol} (${kind}). Current: ${current_price}, Stop: ${stop}`);
+    return placeTpOrder3(client, {
+      symbol,
+      tp: stop,
+      quantity,
+      kind,
+      cancel,
+      price_places,
+      decimal_places
+    });
+  }
+  if (payload.cancel) {
+    await cancelAllOrders3(client, symbol, {
+      type: "stop",
+      kind: payload.kind
+    });
+    if (payload.hedge) {
+      const r_kind = payload.kind === "long" ? "short" : "long";
+      await cancelAllOrders3(client, symbol, {
+        type: "stop",
+        kind: r_kind
+      });
+    }
+  }
+  const spread = 1.00005;
+  const order = {
+    kind: payload.kind,
+    side: payload.kind === "long" ? "sell" : "buy",
+    price: payload.kind === "long" ? payload.stop * spread ** -1 : payload.stop * spread,
+    quantity: payload.quantity,
+    stop: payload.final_stop,
+    is_market: !payload.is_limit
+  };
+  if (payload.hedge) {
+    let reverse_kind = payload.kind === "long" ? "short" : "long";
+    order.kind = reverse_kind;
+    order.is_market = false;
+  }
+  const current_account_info = await fetchBinanceAccount2(client, {
+    symbol: payload.symbol
+  }, {
+    price_places: payload.price_places,
+    decimal_places: payload.decimal_places
+  });
+  const position2 = order.kind === "long" ? current_account_info.long_position : current_account_info.short_position;
+  position2.stop_loss = order.stop;
+  position2.stop_quantity = order.quantity;
+  const allOrders = await getOpenOrders3(client, symbol);
+  const sameKindOrders = allOrders.filter((o) => o.positionSide.toLowerCase() === order.kind);
+  const stop_loss = {
+    price: order.stop,
+    quantity: order.quantity
+  };
+  const { trades } = transformExchangeOrderToTradeWithValidation(sameKindOrders, {
+    validateQuantity: false,
+    validatePrice: false
+  });
+  return savePaperDetails(client, {
+    kind: order.kind,
+    symbol: payload.symbol,
+    decimal_places: payload.decimal_places,
+    price_places: payload.price_places
+  }, {
+    position: {},
+    orders: trades,
+    stop_loss
+  });
+}
+async function placeTpOrder3(client, payload) {
+  const {
+    symbol,
+    kind,
+    price_places = "%.1f",
+    decimal_places = "%.3f"
+  } = payload;
+  if (payload.cancel) {
+    await cancelAllOrders3(client, symbol, {
+      type: "tp",
+      kind
+    });
+  }
+  let _quantity = payload.quantity;
+  if (!_quantity) {
+    const positionInfo = await getPositionInfo3(client, symbol);
+    _quantity = positionInfo[payload.kind]?.size || 0;
+  }
+  if (_quantity) {
+    const order = {
+      kind: payload.kind,
+      side: payload.kind === "long" ? "sell" : "buy",
+      price: payload.tp,
+      quantity: _quantity
+    };
+    const current_account_info = await fetchBinanceAccount2(client, {
+      symbol: payload.symbol
+    }, {
+      price_places: payload.price_places,
+      decimal_places: payload.decimal_places
+    });
+    const position2 = order.kind === "long" ? current_account_info.long_position : current_account_info.short_position;
+    position2.take_profit = order.price;
+    position2.tp_quantity = order.quantity;
+    const allOrders = await getOpenOrders3(client, symbol);
+    const sameKindOrders = allOrders.filter((o) => o.positionSide.toLowerCase() === order.kind);
+    const take_profit = {
+      price: order.price,
+      quantity: order.quantity
+    };
+    const { trades } = transformExchangeOrderToTradeWithValidation(sameKindOrders, {
+      validateQuantity: false,
+      validatePrice: false
+    });
+    return savePaperDetails(client, {
+      kind: order.kind,
+      symbol: payload.symbol,
+      decimal_places,
+      price_places
+    }, {
+      position: {},
+      orders: trades,
+      take_profit
+    });
+  }
+  return { error: "No quantity" };
+}
+async function cancelAllOrders3(client, symbol, payload) {
+  const { type, side, kind } = payload;
+  const {
+    orders: fullOrders,
+    symbol_config,
+    positions
+  } = await fetchDBExchangeData(client, symbol);
+  const allOrders = await getOpenOrders3(client, symbol, type);
+  const sameKindOrders = fullOrders.filter((o) => o.positionSide.toLowerCase() === kind);
+  const ordersToCancel = allOrders.filter((x) => side ? x.side === side : true).filter((x) => kind ? x.kind === kind : true);
+  const excludeFromSameKind = sameKindOrders.filter((o) => !ordersToCancel.map((u) => u.orderId).includes(o.orderId));
+  await savePaperDetails(client, {
+    kind,
+    symbol,
+    decimal_places: symbol_config.decimal_places,
+    price_places: symbol_config.price_places
+  }, {
+    position: positions[kind] || {},
+    orders: excludeFromSameKind,
+    raw: true,
+    stop_loss: {
+      price: 0,
+      quantity: 0
+    }
+  });
+}
+async function cancelOrdersParallel2(payload) {
+  const client = payload.custom_client;
+  const { orders: fullOrders, symbol_config } = await fetchDBExchangeData(client, payload.symbol);
+  const excludedOrders = fullOrders.filter((o) => !payload.orders.map((p) => p.clientOrderId || p.orderId).includes(o.clientOrderId));
+  const long_orders = excludedOrders.filter((o) => o.positionSide.toLowerCase() === "long");
+  const short_orders = excludedOrders.filter((o) => o.positionSide.toLowerCase() === "short");
+  await savePaperDetails(client, {
+    kind: "long",
+    symbol: payload.symbol,
+    decimal_places: symbol_config.decimal_places,
+    price_places: symbol_config.price_places
+  }, {
+    position: {},
+    raw: true,
+    orders: long_orders
+  });
+  await savePaperDetails(client, {
+    kind: "short",
+    symbol: payload.symbol,
+    decimal_places: symbol_config.decimal_places,
+    price_places: symbol_config.price_places
+  }, {
+    position: {},
+    raw: true,
+    orders: short_orders
+  });
+}
+async function cancelOrders3(payload) {
+  return await cancelOrdersParallel2({
+    symbol: payload.symbol,
+    orders: payload.orders,
+    custom_client: payload.custom_client
+  });
+}
+async function createLimitPurchaseOrders2(client, payload) {
+  const { positions, symbol_config, current_price, raw_data } = await fetchDBExchangeData(client, payload.symbol);
+  const kind = payload.orders[0].kind || payload.kind;
+  const params = {
+    position: {
+      kind,
+      entry: positions[kind]?.entry || 0,
+      quantity: positions[kind]?.quantity || 0
+    },
+    global_config: symbol_config
+  };
+  const generator = new TradeEngine(params);
+  const state = generator.initializeEngine({
+    trades: payload.orders,
+    price: current_price
+  });
+  const current_position_state = {
+    entry: state.position.entry,
+    quantity: state.position.quantity
+  };
+  const remaining_orders = state.newTrades;
+  console.log({
+    length: remaining_orders.length,
+    position: current_position_state,
+    last: remaining_orders[remaining_orders.length - 1]
+  });
+  return await updateDbDetails(client, {
+    kind,
+    symbol: payload.symbol
+  }, raw_data, {
+    position: current_position_state,
+    orders: remaining_orders
+  });
+  return await savePaperDetails(client, {
+    kind,
+    symbol: payload.symbol,
+    price_places: payload.price_places,
+    decimal_places: payload.decimal_places
+  }, {
+    position: current_position_state,
+    orders: remaining_orders
+  });
+}
+
+class PaperBinanceExchange extends BaseExchange {
+  constructor(client) {
+    super(client);
+    this.name = "paper";
+    this.client = client;
+  }
+  async getPositionInfo(symbol) {
+    return await getPositionInfo3(this.client, symbol);
+  }
+  async getCurrentPrice(symbol) {
+    return await getCurrentPrice3(this.client.client, symbol);
+  }
+  async cancelAllOrders(symbol, payload) {
+    return await cancelAllOrders3(this.client, symbol, payload);
+  }
+  async _createLimitPurchaseOrders(payload) {
+    return await createLimitPurchaseOrders2(this.client, payload);
+  }
+  async analyzeCharts(_payload) {}
+  async getExchangeInfo(options) {
+    return await fetchBinanceAccount2(this.client, {
+      symbol: options.symbol
+    }, {
+      price_places: options.price_places,
+      decimal_places: options.decimal_places
+    });
+  }
+  async _cancelOrders(payload) {
+    return await cancelOrders3({
+      symbol: payload.symbol,
+      orders: payload.orders,
+      custom_client: this.client
+    });
+  }
+  async _placeTpOrder(payload) {
+    return await placeTpOrder3(this.client, payload);
+  }
+  async placeLimitOrders(payload) {
+    const { price_places = "%.1f", decimal_places = "%.3f", symbol } = payload;
+    if (payload.cancel) {
+      await cancelAllOrders3(this.client, symbol, {
+        type: "limit",
+        kind: payload.kind
+      });
+    }
+    if (payload.orders) {
+      const orders = payload.orders.map((x) => ({
+        side: payload.kind === "long" ? "buy" : "sell",
+        price: x.entry,
+        quantity: x.quantity,
+        kind: payload.kind
+      }));
+      return await createLimitPurchaseOrders2(this.client, {
+        symbol,
+        kind: payload.kind,
+        price_places,
+        decimal_places,
+        orders
+      });
+    }
+  }
+  async _placeStopOrder(payload) {
+    return await placeStopOrder3(this.client, payload);
+  }
+  async setLeverage(payload) {
+    return payload.leverage;
+  }
+  async generateConfig(_payload) {
+    return {};
+  }
+  async checkDelistedMovers(payload) {
+    return { movers: [], delisted: [] };
+  }
+  async getAllOpenOrders() {
+    return [];
+  }
+  async getDelistedSpotSymbols() {
+    return [];
+  }
+  async getOpenPositions() {
+    const response = [];
+    return Array.from(new Set(response.map((x) => x.symbol)));
+  }
+  async getOpenOrders(payload) {
+    return await getOpenOrders3(this.client, payload.symbol);
+  }
+  async createLimitPurchaseOrders(payload) {
+    const {
+      orders,
+      kind,
+      decimal_places = "%.3f",
+      price_places = "%.1f",
+      symbol
+    } = payload;
+    const order_payload = orders.map((order) => ({
+      ...order,
+      price: order.entry,
+      kind,
+      side: kind.toLowerCase() === "long" ? "buy" : "sell",
+      stop: undefined
+    }));
+    return await this._createLimitPurchaseOrders({
+      symbol,
+      price_places,
+      decimal_places,
+      orders: order_payload,
+      kind
+    });
+  }
+  async forceClosePosition(symbol, options) {
+    return await forceClosePosition2(this.client, symbol, options);
+  }
+  async getObservableState(_payload) {
+    const { kind } = _payload;
+    const {
+      positions,
+      symbol_config,
+      current_price,
+      orders: _orders,
+      trades,
+      config: config2
+    } = await fetchDBExchangeData(this.client, _payload.symbol);
+    const generator = new TradeEngine({
+      position: {
+        kind,
+        entry: positions[kind]?.entry || 0,
+        quantity: positions[kind]?.quantity || 0
+      },
+      global_config: symbol_config
+    });
+    const long_state = generator.initializeEngine({
+      config: config2[kind],
+      price: current_price,
+      trades: trades.long
+    });
+    return long_state;
+  }
+  async crossAccountTransfer(payload) {}
+  async placeMarketOrder(payload) {
+    return this.forceClosePosition(payload.symbol, {
+      kind: payload.kind,
+      price_places: payload.price_places,
+      decimal_places: payload.decimal_places
+    });
+  }
+}
+async function forceClosePosition2(client, symbol, options) {
+  const { price_places = "%.1f", decimal_places = "%.3f" } = options || {};
+  await savePaperDetails(client, {
+    symbol,
+    kind: options.kind,
+    decimal_places,
+    price_places
+  }, {
+    raw: true,
+    position: {
+      entry: 0,
+      quantity: 0
+    },
+    take_profit: {
+      price: 0,
+      quantity: 0
+    },
+    stop_loss: {
+      price: 0,
+      quantity: 0
+    },
+    orders: []
+  });
+}
+
+// src/exchange-account.ts
+class ExchangeAccount {
+  instance;
+  exchange;
+  main_exchange;
+  app_db;
+  long_position;
+  short_position;
+  raw_positions;
+  constructor(payload, options) {
+    this.instance = payload;
+    this.exchange = options.exchange;
+    this.app_db = options.app_db;
+    this.main_exchange = options.main_exchange;
+  }
+  getDBInstance() {
+    return this.app_db;
+  }
+  async getLiveExchangeInstance(payload) {
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol: payload.symbol,
+      refresh: payload.refresh_symbol_config
+    });
+    const result = await this.app_db.getLiveExchangeInstance({
+      account: this.instance,
+      symbol: payload.symbol
+    });
+    if (payload.refresh || !result) {
+      const data = await this.exchange.getExchangeAccountInfo({
+        account: this.instance,
+        symbol: payload.symbol,
+        price_places: symbol_config?.price_places,
+        decimal_places: symbol_config?.decimal_places
+      });
+      if (symbol_config?.price_places) {
+        data.config.price_places = symbol_config.price_places;
+      }
+      if (symbol_config?.decimal_places) {
+        data.config.decimal_places = symbol_config.decimal_places;
+      }
+      return await this.app_db.createOrUpdateLiveExchangeInstance({
+        account: this.instance,
+        symbol: payload.symbol,
+        data
+      });
+    }
+    return result;
+  }
+  async initializePositions(payload) {
+    const raw_positions = await this.syncAccount({
+      update: payload.update,
+      symbol: payload.symbol,
+      live_refresh: payload.update
+    });
+    const positions = await this.syncAccount({
+      symbol: payload.symbol,
+      as_view: true
     });
     const active_account = await this.getActiveAccount({
       symbol: payload.symbol
     });
-    console.log("active_account", payload);
+    console.log("positions", raw_positions);
     const long_position = positions.find((x) => x.kind === "long");
     const short_position = positions.find((x) => x.kind === "short");
     this.long_position = new ExchangePosition({
@@ -72030,7 +73876,7 @@ class ExchangeAccount {
   }
   async getActiveAccount(payload) {
     const { symbol, full = false, refresh = false } = payload;
-    const symbol_config = await this.recomputeSymbolConfig({
+    let symbol_config = await this.recomputeSymbolConfig({
       symbol
     });
     const live_exchange_instance = await this.getLiveExchangeInstance({
@@ -72038,6 +73884,8 @@ class ExchangeAccount {
       refresh
     });
     const raw_active_account = live_exchange_instance.data;
+    console.log("raw_active", raw_active_account);
+    console.log("symbol_config", symbol_config);
     const _all = get_active_accounts({
       active_account: raw_active_account,
       symbol_config
@@ -72053,6 +73901,7 @@ class ExchangeAccount {
       refresh: live_refresh,
       symbol
     });
+    console.log("active_accounts", active_account, live_refresh);
     if (leverage) {
       this.exchange.setLeverage({ symbol, leverage });
     }
@@ -72305,7 +74154,7 @@ class ExchangeAccount {
       kind: "short"
     });
     const long_config = await long_position.getConfig();
-    const short_config = short_position.getInstance().expand.b_config;
+    const short_config = await short_position.getConfig();
     const config2 = build_reduce_config({
       account: this.instance,
       symbol: payload.symbol,
@@ -73667,9 +75516,9 @@ class ExchangeAccount {
     return profiles;
   }
 }
-function getExchangeKlass(exchange) {
-  const func = exchange === "binance" ? BinanceExchange : BybitExchange;
-  const clientFunc = exchange === "binance" ? initClient : initClient2;
+function getExchangeKlass(exchange, dbCredentials) {
+  const func = exchange === "binance" ? BinanceExchange : exchange === "paper" ? PaperBinanceExchange : BybitExchange;
+  const clientFunc = exchange === "binance" ? initClient : exchange === "paper" ? initClient3 : initClient2;
   return async (payload) => {
     const credentials = await payload.getCredentials({
       account: payload.account,
@@ -73677,7 +75526,8 @@ function getExchangeKlass(exchange) {
     });
     const client = await clientFunc(credentials, {
       type: "future",
-      proxyAgent: payload.proxyAgent
+      proxyAgent: payload.proxyAgent,
+      db: dbCredentials
     });
     let main_client = null;
     if (exchange === "binance") {
@@ -73703,7 +75553,11 @@ async function getExchangeAccount(payload) {
   const { account, app_db, proxyOptions = {}, canWithdraw = false } = payload;
   const _proxyAgent = await app_db.getProxyForAccount(account);
   const proxyAgent = proxyOptions?.ignore_proxy ? null : proxyOptions?.proxy || _proxyAgent;
-  const exchange_instance = await getExchangeKlass(account.exchange)({
+  const exchange_instance = await getExchangeKlass(account.exchange, {
+    host: app_db.pb.baseURL,
+    email: app_db.root_email,
+    password: app_db.root_password
+  })({
     account: account.owner,
     getCredentials: async (_payload) => {
       return await payload.getCredentials({ ..._payload, app_db });
@@ -74113,7 +75967,11 @@ async function initApp(payload) {
   const pb = await initPocketBaseClient(payload.db);
   const app_db = new AppDatabase(pb, {
     email: payload.email,
-    salt: payload.salt
+    salt: payload.salt,
+    db: {
+      email: payload.db.email,
+      password: payload.db.password
+    }
   });
   let _getCredentials = payload.getCredentials;
   if (payload.password) {