@gbozee/ultimate 0.0.2-next.23 → 0.0.2-next.24

package/dist/index.cjs

@@ -50646,19 +50646,92 @@ class AppDatabase {
   }
   async deleteAndBulCreateAllOrders(payload) {
     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 {
@@ -50667,13 +50740,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 = {
@@ -50695,8 +50767,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;
@@ -59004,1582 +59077,350 @@ function convert_to_exchange_order(order) {
 var import_https_proxy_agent3 = __toESM(require_dist2());
 var import_socks_proxy_agent3 = __toESM(require_dist3());
 
-// node_modules/@legendapp/state/index.mjs
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function isArray3(obj) {
-  return Array.isArray(obj);
-}
-function isObject2(obj) {
-  return !!obj && typeof obj === "object" && !isArray3(obj);
-}
-function isFunction(obj) {
-  return typeof obj === "function";
-}
-function isPrimitive2(arg) {
-  const type = typeof arg;
-  return arg !== undefined && (isDate2(arg) || type !== "object" && type !== "function");
-}
-function isDate2(obj) {
-  return obj instanceof Date;
-}
-function isBoolean2(obj) {
-  return typeof obj === "boolean";
-}
-function isPromise(obj) {
-  return obj instanceof Promise;
-}
-function isEmpty(obj) {
-  if (!obj)
-    return false;
-  if (isArray3(obj))
-    return obj.length === 0;
-  for (const key in obj) {
-    if (hasOwnProperty.call(obj, key)) {
-      return false;
-    }
-  }
-  return true;
-}
-var setPrimitives = new Set(["boolean", "string", "number"]);
-function isActualPrimitive(arg) {
-  return setPrimitives.has(typeof arg);
-}
-function isChildNodeValue(node) {
-  return !!node.parent;
-}
-var symbolToPrimitive = Symbol.toPrimitive;
-var symbolGetNode = Symbol("getNode");
-var symbolDelete = /* @__PURE__ */ Symbol("delete");
-var symbolOpaque = Symbol("opaque");
-var optimized = Symbol("optimized");
-var extraPrimitiveActivators = new Map;
-var extraPrimitiveProps = new Map;
-var globalState = {
-  isLoadingLocal: false,
-  isLoadingRemote: false,
-  isMerging: false
-};
-function checkActivate(node) {
-  var _a;
-  const root = node.root;
-  (_a = root.activate) === null || _a === undefined || _a.call(root);
-  if (root.toActivate) {
-    root.toActivate.forEach(checkActivate);
-    delete root.toActivate;
+// src/exchanges/paper/engine-class.ts
+function generateSummary2({
+  trades = [],
+  fee_percent = 0.05,
+  anchor
+}) {
+  if (trades.length === 0) {
+    return {};
   }
+  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 getNode(obs) {
-  return obs && obs[symbolGetNode];
+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();
 }
-function setNodeValue(node, newValue) {
-  var _a;
-  const parentNode = (_a = node.parent) !== null && _a !== undefined ? _a : node;
-  const key = node.parent ? node.key : "_";
-  const isDelete = newValue === symbolDelete;
-  if (isDelete)
-    newValue = undefined;
-  const parentValue = node.parent ? ensureNodeValue(parentNode) : parentNode.root;
-  const prevValue = parentValue[key];
-  const isFunc = isFunction(newValue);
-  newValue = !parentNode.isAssigning && isFunc ? newValue(prevValue) : isObject2(newValue) && (newValue === null || newValue === undefined ? undefined : newValue[symbolGetNode]) ? newValue.peek() : newValue;
-  try {
-    parentNode.isSetting = (parentNode.isSetting || 0) + 1;
-    if (isDelete) {
-      delete parentValue[key];
-    } else {
-      parentValue[key] = newValue;
+
+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 [];
     }
-  } finally {
-    parentNode.isSetting--;
-  }
-  if (parentNode.root.locked && parentNode.root.set) {
-    parentNode.root.set(parentNode.root._);
-  }
-  return { prevValue, newValue, parentValue };
-}
-var arrNodeKeys = [];
-function getNodeValue(node) {
-  let count = 0;
-  let n2 = node;
-  while (isChildNodeValue(n2)) {
-    arrNodeKeys[count++] = n2.key;
-    n2 = n2.parent;
-  }
-  let child = node.root._;
-  for (let i2 = count - 1;child && i2 >= 0; i2--) {
-    const key = arrNodeKeys[i2];
-    child = key !== "size" && (child instanceof Map || child instanceof WeakMap) ? child.get(key) : child[key];
+    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
+      };
+    });
+    return processedTrades.reverse();
   }
-  return child;
-}
-function getChildNode(node, key) {
-  var _a;
-  let child = (_a = node.children) === null || _a === undefined ? undefined : _a.get(key);
-  if (!child) {
-    child = {
-      root: node.root,
-      parent: node,
-      key,
-      lazy: true
+  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")
     };
-    if (!node.children) {
-      node.children = new Map;
-    }
-    node.children.set(key, child);
-  }
-  return child;
-}
-function ensureNodeValue(node) {
-  let value2 = getNodeValue(node);
-  if (!value2) {
-    if (isChildNodeValue(node)) {
-      const parent = ensureNodeValue(node.parent);
-      value2 = parent[node.key] = {};
-    } else {
-      value2 = node.root._ = {};
-    }
   }
-  return value2;
-}
-function findIDKey(obj, node) {
-  let idKey = isObject2(obj) ? "id" in obj ? "id" : ("key" in obj) ? "key" : ("_id" in obj) ? "_id" : ("__id" in obj) ? "__id" : undefined : undefined;
-  if (!idKey && node.parent) {
-    const keyExtractor = getNodeValue(node.parent)[node.key + "_keyExtractor"];
-    if (keyExtractor && isFunction(keyExtractor)) {
-      idKey = keyExtractor;
-    }
+  get summary() {
+    return this.generateSummary();
   }
-  return idKey;
-}
-function extractFunction(node, key, fnOrComputed, computedChildNode) {
-  if (!node.functions) {
-    node.functions = new Map;
+  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];
   }
-  node.functions.set(key, fnOrComputed);
-  if (computedChildNode) {
-    computedChildNode.parentOther = getChildNode(node, key);
-    if (!node.root.toActivate) {
-      node.root.toActivate = [];
+  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
+      });
     }
-    node.root.toActivate.push(computedChildNode);
-  }
-}
-function isObservable(obs) {
-  return obs && !!obs[symbolGetNode];
-}
-function isEvent(obs) {
-  var _a;
-  return obs && ((_a = obs[symbolGetNode]) === null || _a === undefined ? undefined : _a.isEvent);
-}
-function computeSelector(selector, e2, retainObservable) {
-  let c = selector;
-  if (isFunction(c)) {
-    c = e2 ? c(e2) : c();
+    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
+    });
   }
-  return isObservable(c) && !retainObservable ? c.get() : c;
-}
-function lockObservable(obs, value2) {
-  var _a;
-  const root = (_a = getNode(obs)) === null || _a === undefined ? undefined : _a.root;
-  if (root) {
-    root.locked = value2;
+  updateTakeProfit({ entry, quantity }) {
+    this.take_profit = {
+      price: entry,
+      quantity: quantity ?? this.position.quantity
+    };
   }
-}
-function getPathType(value2) {
-  return isArray3(value2) ? "array" : value2 instanceof Map ? "map" : value2 instanceof Set ? "set" : "object";
-}
-function replacer(_, value2) {
-  if (value2 instanceof Map) {
-    return {
-      __LSType: "Map",
-      value: Array.from(value2.entries())
+  updateStopLoss(payload) {
+    const { stop, quantity } = payload ?? {
+      stop: this.newTrades[0].entry,
+      quantity: this.summary.quantity
     };
-  } else if (value2 instanceof Set) {
-    return {
-      __LSType: "Set",
-      value: Array.from(value2)
+    this.stop_loss = {
+      price: stop,
+      quantity
     };
-  } else {
-    return value2;
-  }
-}
-function reviver(_, value2) {
-  if (typeof value2 === "object" && value2) {
-    if (value2.__LSType === "Map") {
-      return new Map(value2.value);
-    } else if (value2.__LSType === "Set") {
-      return new Set(value2.value);
-    }
-  }
-  return value2;
-}
-function safeStringify(value2) {
-  return JSON.stringify(value2, replacer);
-}
-function safeParse(value2) {
-  return JSON.parse(value2, reviver);
-}
-function clone2(value2) {
-  return safeParse(safeStringify(value2));
-}
-var timeout4;
-var numInBatch = 0;
-var isRunningBatch = false;
-var didDelayEndBatch = false;
-var _afterBatch = [];
-var _queuedBatches = [];
-var _batchMap = new Map;
-function onActionTimeout() {
-  if (_batchMap.size > 0) {
-    if (true) {
-      console.error("Forcibly completing observableBatcher because end() was never called. This may be due to an uncaught error between begin() and end().");
-    }
-    endBatch(true);
   }
 }
-function isArraySubset(mainArr, subsetArr) {
-  for (let i2 = 0;i2 < mainArr.length; i2++) {
-    if (mainArr[i2] !== subsetArr[i2]) {
-      return false;
+function determineNewPosition({
+  position: position2,
+  price,
+  trades,
+  global_config
+}) {
+  const kind = position2.kind;
+  const placed = trades.filter((t2) => {
+    if (kind === "long") {
+      return t2.entry >= price;
     }
-  }
-  return true;
-}
-function createPreviousHandlerInner(value2, changes) {
-  let cloned = value2 ? clone2(value2) : {};
-  for (let i2 = 0;i2 < changes.length; i2++) {
-    const { path, prevAtPath } = changes[i2];
-    let o = cloned;
-    if (path.length > 0) {
-      let i3;
-      for (i3 = 0;i3 < path.length - 1; i3++) {
-        o = o[path[i3]];
-      }
-      const key = path[i3];
-      if (o instanceof Map) {
-        o.set(key, prevAtPath);
-      } else {
-        o[key] = prevAtPath;
+    return t2.entry <= price;
+  });
+  const placeQty = placed.reduce((acc, trade) => acc + trade.quantity, 0);
+  if (position2.quantity > 0) {
+    const placed_less_than_entry = placed.filter((t2) => {
+      if (kind === "long") {
+        return t2.entry < position2.entry;
       }
-    } else {
-      cloned = prevAtPath;
-    }
+      return t2.entry > position2.entry;
+    });
+    const avg = determine_average_entry_and_size(placed_less_than_entry.map((o) => ({
+      price: o.entry,
+      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 cloned;
-}
-function createPreviousHandler(value2, changes) {
-  return function() {
-    return createPreviousHandlerInner(value2, changes);
+  return {
+    ...position2,
+    entry: price,
+    quantity: placeQty
   };
 }
-function notify(node, value2, prev, level, whenOptimizedOnlyIf) {
-  const changesInBatch = new Map;
-  computeChangesRecursive(changesInBatch, node, value2, [], [], value2, prev, true, level, whenOptimizedOnlyIf);
-  batchNotifyChanges(changesInBatch, true);
-  const existing = _batchMap.get(node);
-  if (existing) {
-    existing.value = value2;
-  } else {
-    _batchMap.set(node, { value: value2, prev, level, whenOptimizedOnlyIf });
-  }
-  if (numInBatch <= 0) {
-    runBatch();
-  }
-}
-function computeChangesAtNode(changesInBatch, node, value2, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
-  if (immediate ? node.listenersImmediate : node.listeners) {
-    const change = {
-      path,
-      pathTypes,
-      valueAtPath,
-      prevAtPath
-    };
-    const changeInBatch = changesInBatch.get(node);
-    if (changeInBatch && path.length > 0) {
-      const { changes } = changeInBatch;
-      if (!isArraySubset(changes[0].path, change.path)) {
-        changes.push(change);
-      }
-    } else {
-      changesInBatch.set(node, {
-        level,
-        value: value2,
-        whenOptimizedOnlyIf,
-        changes: [change]
-      });
-    }
-  }
-}
-function computeChangesRecursive(changesInBatch, node, value2, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
-  computeChangesAtNode(changesInBatch, node, value2, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);
-  if (node.linkedFromNodes) {
-    for (const linkedFromNode of node.linkedFromNodes) {
-      computeChangesAtNode(changesInBatch, linkedFromNode, value2, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);
-    }
-  }
-  if (node.parent) {
-    const parent = node.parent;
-    if (parent) {
-      const parentValue = getNodeValue(parent);
-      computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [getPathType(value2)].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
-    }
-  }
-}
-function batchNotifyChanges(changesInBatch, immediate) {
-  const listenersNotified = new Set;
-  changesInBatch.forEach(({ changes, level, value: value2, whenOptimizedOnlyIf }, node) => {
-    const listeners = immediate ? node.listenersImmediate : node.listeners;
-    if (listeners) {
-      let listenerParams;
-      const arr = Array.from(listeners);
-      for (let i2 = 0;i2 < arr.length; i2++) {
-        const listenerFn = arr[i2];
-        const { track, noArgs, listener } = listenerFn;
-        if (!listenersNotified.has(listener)) {
-          const ok = track === true ? level <= 0 : track === optimized ? whenOptimizedOnlyIf && level <= 0 : true;
-          if (ok) {
-            if (!noArgs && !listenerParams) {
-              listenerParams = {
-                value: value2,
-                getPrevious: createPreviousHandler(value2, changes),
-                changes
-              };
-            }
-            if (!track) {
-              listenersNotified.add(listener);
-            }
-            listener(listenerParams);
-          }
-        }
-      }
+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) => {
+    if (kind === "long") {
+      return t2.entry >= price;
     }
+    return t2.entry <= price;
   });
-}
-function runBatch() {
-  const map = _batchMap;
-  _batchMap = new Map;
-  const changesInBatch = new Map;
-  map.forEach(({ value: value2, prev, level, whenOptimizedOnlyIf }, node) => {
-    computeChangesRecursive(changesInBatch, node, value2, [], [], value2, prev, false, level, whenOptimizedOnlyIf);
-  });
-  batchNotifyChanges(changesInBatch, false);
-}
-function batch2(fn, onComplete) {
-  if (onComplete) {
-    if (isRunningBatch) {
-      _queuedBatches.push([fn, onComplete]);
-      return;
-    } else {
-      _afterBatch.push(onComplete);
-    }
-  }
-  beginBatch();
-  try {
-    fn();
-  } finally {
-    endBatch();
-  }
-}
-function beginBatch() {
-  numInBatch++;
-  if (!timeout4) {
-    timeout4 = setTimeout(onActionTimeout, 0);
-  }
-}
-function endBatch(force) {
-  numInBatch--;
-  if (numInBatch <= 0 || force) {
-    if (isRunningBatch) {
-      didDelayEndBatch = true;
-    } else {
-      if (timeout4) {
-        clearTimeout(timeout4);
-        timeout4 = undefined;
-      }
-      numInBatch = 0;
-      const after = _afterBatch;
-      if (after.length) {
-        _afterBatch = [];
-      }
-      isRunningBatch = true;
-      runBatch();
-      isRunningBatch = false;
-      for (let i2 = 0;i2 < after.length; i2++) {
-        after[i2]();
-      }
-      if (didDelayEndBatch) {
-        didDelayEndBatch = false;
-        endBatch(true);
-      }
-      const queued = _queuedBatches;
-      if (queued.length) {
-        _queuedBatches = [];
-        for (let i2 = 0;i2 < queued.length; i2++) {
-          const [fn, onComplete] = queued[i2];
-          batch2(fn, onComplete);
-        }
-      }
-    }
-  }
-}
-function createObservable(value2, makePrimitive, createObject, createPrimitive) {
-  const valueIsPromise = isPromise(value2);
-  const root = {
-    _: value2
-  };
-  const node = {
-    root,
-    lazy: true
-  };
-  const prim = makePrimitive || isActualPrimitive(value2);
-  const obs = prim ? new createPrimitive(node) : createObject(node);
-  if (valueIsPromise) {
-    extractPromise(node, value2);
-  }
-  return obs;
-}
-function onChange(node, callback, options = {}) {
-  const { initial, immediate, noArgs } = options;
-  const { trackingType } = options;
-  let listeners = immediate ? node.listenersImmediate : node.listeners;
-  if (!listeners) {
-    listeners = new Set;
-    if (immediate) {
-      node.listenersImmediate = listeners;
-    } else {
-      node.listeners = listeners;
+  const not_placed = trades.filter((t2) => {
+    if (kind === "long") {
+      return t2.entry < price;
     }
-  }
-  checkActivate(node);
-  const listener = {
-    listener: callback,
-    track: trackingType,
-    noArgs
+    return t2.entry > price;
+  });
+  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
   };
-  listeners.add(listener);
-  if (initial) {
-    const value2 = getNodeValue(node);
-    callback({
-      value: value2,
-      changes: [
-        {
-          path: [],
-          pathTypes: [],
-          prevAtPath: value2,
-          valueAtPath: value2
-        }
-      ],
-      getPrevious: () => {
-        return;
-      }
+  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 () => listeners.delete(listener);
-}
-var trackCount = 0;
-var trackingQueue = [];
-var tracking = {
-  current: undefined
-};
-function beginTracking() {
-  trackingQueue.push(tracking.current);
-  trackCount++;
-  tracking.current = {};
-}
-function endTracking() {
-  trackCount--;
-  if (trackCount < 0) {
-    trackCount = 0;
-  }
-  tracking.current = trackingQueue.pop();
-}
-function updateTracking(node, track) {
-  if (trackCount) {
-    const tracker = tracking.current;
-    if (tracker) {
-      if (!tracker.nodes) {
-        tracker.nodes = new Map;
-      }
-      const existing = tracker.nodes.get(node);
-      if (existing) {
-        existing.track = existing.track || track;
-        existing.num++;
-      } else {
-        tracker.nodes.set(node, { node, track, num: 1 });
-      }
-    }
-  }
-}
-var ArrayModifiers = new Set([
-  "copyWithin",
-  "fill",
-  "from",
-  "pop",
-  "push",
-  "reverse",
-  "shift",
-  "sort",
-  "splice",
-  "unshift"
-]);
-var ArrayLoopers = new Set([
-  "every",
-  "filter",
-  "find",
-  "findIndex",
-  "forEach",
-  "join",
-  "map",
-  "some"
-]);
-var ArrayLoopersReturn = new Set(["filter", "find"]);
-var observableProperties = new Map;
-var observableFns = new Map([
-  ["get", get3],
-  ["set", set],
-  ["peek", peek],
-  ["onChange", onChange],
-  ["assign", assign],
-  ["delete", deleteFn],
-  ["toggle", toggle]
-]);
-if (true) {
-  __devUpdateNodes = new Set;
-}
-var __devUpdateNodes;
-function collectionSetter(node, target, prop, ...args) {
-  var _a;
-  const prevValue = isArray3(target) && target.slice() || target;
-  const ret = target[prop].apply(target, args);
-  if (node) {
-    const hasParent = isChildNodeValue(node);
-    const key = hasParent ? node.key : "_";
-    const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
-    parentValue[key] = prevValue;
-    setKey((_a = node.parent) !== null && _a !== undefined ? _a : node, key, target);
-  }
-  return ret;
-}
-function getKeys(obj, isArr, isMap2) {
-  return isArr ? undefined : obj ? isMap2 ? Array.from(obj.keys()) : Object.keys(obj) : [];
-}
-function updateNodes(parent, obj, prevValue) {
-  var _a, _b;
-  if (typeof __devUpdateNodes !== "undefined" && isObject2(obj)) {
-    if (__devUpdateNodes.has(obj)) {
-      console.error("[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.", obj);
-      return false;
-    }
-    __devUpdateNodes.add(obj);
-  }
-  if (isObject2(obj) && obj[symbolOpaque] || isObject2(prevValue) && prevValue[symbolOpaque]) {
-    const isDiff = obj !== prevValue;
-    if (isDiff) {
-      if (parent.listeners || parent.listenersImmediate) {
-        notify(parent, obj, prevValue, 0);
-      }
-    }
-    if (typeof __devUpdateNodes !== "undefined" && obj !== undefined) {
-      __devUpdateNodes.delete(obj);
-    }
-    return isDiff;
-  }
-  const isArr = isArray3(obj);
-  let prevChildrenById;
-  let moved;
-  const isMap2 = obj instanceof Map;
-  const keys = getKeys(obj, isArr, isMap2);
-  const keysPrev = getKeys(prevValue, isArr, isMap2);
-  const length = ((_a = keys || obj) === null || _a === undefined ? undefined : _a.length) || 0;
-  const lengthPrev = ((_b = keysPrev || prevValue) === null || _b === undefined ? undefined : _b.length) || 0;
-  let idField;
-  let isIdFieldFunction;
-  let hasADiff = false;
-  let retValue;
-  if (isArr && isArray3(prevValue)) {
-    if (prevValue.length > 0) {
-      const firstPrevValue = prevValue[0];
-      if (firstPrevValue !== undefined) {
-        idField = findIDKey(firstPrevValue, parent);
-        if (idField) {
-          isIdFieldFunction = isFunction(idField);
-          prevChildrenById = new Map;
-          moved = [];
-          const keysSeen = new Set;
-          if (parent.children) {
-            for (let i2 = 0;i2 < prevValue.length; i2++) {
-              const p = prevValue[i2];
-              if (p) {
-                const child = parent.children.get(i2 + "");
-                if (child) {
-                  const key = isIdFieldFunction ? idField(p) : p[idField];
-                  if (true) {
-                    if (keysSeen.has(key)) {
-                      console.warn(`[legend-state] Warning: Multiple elements in array have the same ID. Key field: ${idField}, Array:`, prevValue);
-                    }
-                    keysSeen.add(key);
-                  }
-                  prevChildrenById.set(key, child);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  } else if (prevValue && (!obj || isObject2(obj))) {
-    const lengthPrev2 = keysPrev.length;
-    for (let i2 = 0;i2 < lengthPrev2; i2++) {
-      const key = keysPrev[i2];
-      if (!keys.includes(key)) {
-        hasADiff = true;
-        const child = getChildNode(parent, key);
-        const prev = isMap2 ? prevValue.get(key) : prevValue[key];
-        if (prev !== undefined) {
-          if (!isPrimitive2(prev)) {
-            updateNodes(child, undefined, prev);
-          }
-          if (child.listeners || child.listenersImmediate) {
-            notify(child, undefined, prev, 0);
-          }
-        }
-      }
-    }
-  }
-  if (obj && !isPrimitive2(obj)) {
-    hasADiff = hasADiff || length !== lengthPrev;
-    const isArrDiff = hasADiff;
-    let didMove = false;
-    for (let i2 = 0;i2 < length; i2++) {
-      const key = isArr ? i2 + "" : keys[i2];
-      const value2 = isMap2 ? obj.get(key) : obj[key];
-      const prev = isMap2 ? prevValue === null || prevValue === undefined ? undefined : prevValue.get(key) : prevValue === null || prevValue === undefined ? undefined : prevValue[key];
-      let isDiff = value2 !== prev;
-      if (isDiff) {
-        const id = idField && value2 ? isIdFieldFunction ? idField(value2) : value2[idField] : undefined;
-        let child = getChildNode(parent, key);
-        if (isArr && id !== undefined) {
-          const prevChild = id !== undefined ? prevChildrenById === null || prevChildrenById === undefined ? undefined : prevChildrenById.get(id) : undefined;
-          if (!prevChild) {
-            isDiff = false;
-            hasADiff = true;
-          } else if (prevChild !== undefined && prevChild.key !== key) {
-            const valuePrevChild = prevValue[prevChild.key];
-            if (isArrDiff) {
-              child = prevChild;
-              parent.children.delete(child.key);
-              child.key = key;
-              moved.push([key, child]);
-            }
-            didMove = true;
-            isDiff = valuePrevChild !== value2;
-          }
-        }
-        if (isDiff) {
-          if (isPrimitive2(value2)) {
-            hasADiff = true;
-          } else {
-            const updatedNodes = updateNodes(child, value2, prev);
-            hasADiff = hasADiff || updatedNodes;
-          }
-        }
-        if (isDiff || !isArrDiff) {
-          if (child.listeners || child.listenersImmediate) {
-            notify(child, value2, prev, 0, !isArrDiff);
-          }
-        }
-      }
-    }
-    if (moved) {
-      for (let i2 = 0;i2 < moved.length; i2++) {
-        const [key, child] = moved[i2];
-        parent.children.set(key, child);
-      }
-    }
-    retValue = hasADiff || didMove;
-  } else if (prevValue !== undefined) {
-    retValue = true;
-  }
-  if (typeof __devUpdateNodes !== "undefined" && obj !== undefined) {
-    __devUpdateNodes.delete(obj);
-  }
-  return retValue !== null && retValue !== undefined ? retValue : false;
-}
-function getProxy(node, p) {
-  if (p !== undefined)
-    node = getChildNode(node, p);
-  return node.proxy || (node.proxy = new Proxy(node, proxyHandler));
-}
-var proxyHandler = {
-  get(node, p, receiver) {
-    var _a;
-    if (p === symbolToPrimitive) {
-      throw new Error("[legend-state] observable should not be used as a primitive. You may have forgotten to use .get() or .peek() to get the value of the observable.");
-    }
-    if (p === symbolGetNode) {
-      return node;
-    }
-    const value2 = peek(node);
-    if (node.linkedToNode && p !== "onChange") {
-      return proxyHandler.get(node.linkedToNode, p, receiver);
-    }
-    if (value2 instanceof Map || value2 instanceof WeakMap || value2 instanceof Set || value2 instanceof WeakSet) {
-      const ret = handlerMapSet(node, p, value2);
-      if (ret !== undefined) {
-        return ret;
-      }
-    }
-    const fn = observableFns.get(p);
-    if (fn) {
-      return function(a, b, c) {
-        const l = arguments.length;
-        switch (l) {
-          case 0:
-            return fn(node);
-          case 1:
-            return fn(node, a);
-          case 2:
-            return fn(node, a, b);
-          default:
-            return fn(node, a, b, c);
-        }
-      };
-    }
-    if (node.isComputed) {
-      if (node.proxyFn && !fn) {
-        return node.proxyFn(p);
-      } else {
-        checkActivate(node);
-      }
-    }
-    const property = observableProperties.get(p);
-    if (property) {
-      return property.get(node);
-    }
-    const isValuePrimitive = isPrimitive2(value2);
-    if (value2 === undefined || value2 === null || isValuePrimitive) {
-      if (extraPrimitiveProps.size && (node.isActivatedPrimitive || extraPrimitiveActivators.has(p))) {
-        node.isActivatedPrimitive = true;
-        const vPrim = extraPrimitiveProps.get(p);
-        if (vPrim !== undefined) {
-          return isFunction(vPrim) ? vPrim(getProxy(node)) : vPrim;
-        }
-      }
-    }
-    const vProp = value2 === null || value2 === undefined ? undefined : value2[p];
-    if (isObject2(value2) && value2[symbolOpaque]) {
-      return vProp;
-    }
-    if (isFunction(vProp)) {
-      if (isArray3(value2)) {
-        if (ArrayModifiers.has(p)) {
-          return (...args) => collectionSetter(node, value2, p, ...args);
-        } else if (ArrayLoopers.has(p)) {
-          updateTracking(node);
-          return function(cbOrig, thisArg) {
-            function cbWrapped(_, index, array) {
-              return cbOrig(getProxy(node, index + ""), index, array);
-            }
-            if (ArrayLoopersReturn.has(p)) {
-              const isFind = p === "find";
-              const out = [];
-              for (let i2 = 0;i2 < value2.length; i2++) {
-                if (cbWrapped(value2[i2], i2, value2)) {
-                  const proxy = getProxy(node, i2 + "");
-                  if (isFind) {
-                    return proxy;
-                  } else {
-                    out.push(proxy);
-                  }
-                }
-              }
-              return isFind ? undefined : out;
-            } else {
-              return value2[p](cbWrapped, thisArg);
-            }
-          };
-        }
-      }
-      return vProp.bind(value2);
-    }
-    if (isPrimitive2(vProp)) {
-      if (isArray3(value2) && p === "length") {
-        updateTracking(node, true);
-        return vProp;
-      }
-    }
-    const fnOrComputed = (_a = node.functions) === null || _a === undefined ? undefined : _a.get(p);
-    if (fnOrComputed) {
-      return fnOrComputed;
-    }
-    if (vProp === undefined && (p === "state" || p === "_state") && node.state) {
-      return node.state;
-    }
-    return getProxy(node, p);
-  },
-  getPrototypeOf(node) {
-    const value2 = getNodeValue(node);
-    return value2 !== null && typeof value2 === "object" ? Reflect.getPrototypeOf(value2) : null;
-  },
-  ownKeys(node) {
-    const value2 = getNodeValue(node);
-    if (isPrimitive2(value2))
-      return [];
-    const keys = value2 ? Reflect.ownKeys(value2) : [];
-    updateTracking(node, true);
-    if (isArray3(value2) && keys[keys.length - 1] === "length") {
-      keys.splice(keys.length - 1, 1);
-    }
-    return keys;
-  },
-  getOwnPropertyDescriptor(node, prop) {
-    const value2 = getNodeValue(node);
-    return !isPrimitive2(value2) ? Reflect.getOwnPropertyDescriptor(value2, prop) : undefined;
-  },
-  set(node, prop, value2) {
-    if (node.isSetting) {
-      return Reflect.set(node, prop, value2);
-    }
-    if (node.isAssigning) {
-      setKey(node, prop, value2);
-      return true;
-    }
-    const property = observableProperties.get(prop);
-    if (property) {
-      property.set(node, value2);
-      return true;
-    }
-    if (true) {
-      console.warn("[legend-state]: Error: Cannot set a value directly:", prop, value2);
-    }
-    return false;
-  },
-  deleteProperty(node, prop) {
-    if (node.isSetting) {
-      return Reflect.deleteProperty(node, prop);
-    } else {
-      if (true) {
-        console.warn("[legend-state]: Error: Cannot delete a value directly:", prop);
-      }
-      return false;
-    }
-  },
-  has(node, prop) {
-    const value2 = getNodeValue(node);
-    return Reflect.has(value2, prop);
-  }
-};
-function set(node, newValue) {
-  if (node.parent) {
-    return setKey(node.parent, node.key, newValue);
-  } else {
-    return setKey(node, "_", newValue);
-  }
-}
-function toggle(node) {
-  const value2 = getNodeValue(node);
-  if (value2 === undefined || isBoolean2(value2)) {
-    set(node, !value2);
-    return !value2;
-  } else if (true) {
-    throw new Error("[legend-state] Cannot toggle a non-boolean value");
-  }
-}
-function setKey(node, key, newValue, level) {
-  if (true) {
-    if (typeof HTMLElement !== "undefined" && newValue instanceof HTMLElement) {
-      console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);
-    }
-  }
-  if (node.root.locked && !node.root.set) {
-    if (globalState.isMerging) {
-      return;
-    } else {
-      throw new Error("[legend-state] Cannot modify an observable while it is locked. Please make sure that you unlock the observable before making changes.");
-    }
-  }
-  const isRoot = !node.parent && key === "_";
-  const childNode = isRoot ? node : getChildNode(node, key);
-  const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);
-  const isFunc = isFunction(savedValue);
-  const isPrim = isPrimitive2(savedValue) || savedValue instanceof Date;
-  if (savedValue !== prevValue) {
-    updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
-  }
-  extractFunctionOrComputed(node, parentValue, key, savedValue);
-  return isFunc ? savedValue : isRoot ? getProxy(node) : getProxy(node, key);
-}
-function assign(node, value2) {
-  const proxy = getProxy(node);
-  beginBatch();
-  if (isPrimitive2(node.root._)) {
-    node.root._ = {};
-  }
-  node.isAssigning = (node.isAssigning || 0) + 1;
-  try {
-    Object.assign(proxy, value2);
-  } finally {
-    node.isAssigning--;
-  }
-  endBatch();
-  return proxy;
-}
-function deleteFn(node, key) {
-  if (key === undefined && isChildNodeValue(node)) {
-    key = node.key;
-    node = node.parent;
-  }
-  setKey(node, key !== null && key !== undefined ? key : "_", symbolDelete, -1);
-}
-function handlerMapSet(node, p, value2) {
-  const vProp = value2 === null || value2 === undefined ? undefined : value2[p];
-  if (p === "size") {
-    return getProxy(node, p);
-  } else if (isFunction(vProp)) {
-    return function(a, b, c) {
-      const l = arguments.length;
-      const valueMap = value2;
-      if (p === "get") {
-        if (l > 0 && typeof a !== "boolean" && a !== optimized) {
-          return getProxy(node, a);
-        }
-      } else if (p === "set") {
-        if (l === 2) {
-          const prev = valueMap.get(a);
-          const ret = valueMap.set(a, b);
-          if (prev !== b) {
-            updateNodesAndNotify(getChildNode(node, a), b, prev);
-          }
-          return ret;
-        }
-      } else if (p === "delete") {
-        if (l > 0) {
-          const prev = value2.get ? valueMap.get(a) : a;
-          const ret = value2.delete(a);
-          if (ret) {
-            updateNodesAndNotify(getChildNode(node, a), undefined, prev);
-          }
-          return ret;
-        }
-      } else if (p === "clear") {
-        const prev = new Map(valueMap);
-        const size = valueMap.size;
-        valueMap.clear();
-        if (size) {
-          updateNodesAndNotify(node, value2, prev);
-        }
-        return;
-      } else if (p === "add") {
-        const prev = new Set(value2);
-        const ret = value2.add(a);
-        if (!value2.has(p)) {
-          notify(node, ret, prev, 0);
-        }
-        return ret;
-      }
-      const fn = observableFns.get(p);
-      if (fn) {
-        switch (l) {
-          case 0:
-            return fn(node);
-          case 1:
-            return fn(node, a);
-          case 2:
-            return fn(node, a, b);
-          default:
-            return fn(node, a, b, c);
-        }
-      } else {
-        return value2[p](a, b);
-      }
-    };
-  }
-}
-function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level) {
-  if (!childNode)
-    childNode = node;
-  beginBatch();
-  if (isPrim === undefined) {
-    isPrim = isPrimitive2(newValue);
-  }
-  let hasADiff = isPrim;
-  let whenOptimizedOnlyIf = false;
-  if (!isPrim || prevValue && !isPrimitive2(prevValue)) {
-    if (typeof __devUpdateNodes !== "undefined") {
-      __devUpdateNodes.clear();
-    }
-    hasADiff = updateNodes(childNode, newValue, prevValue);
-    if (isArray3(newValue)) {
-      whenOptimizedOnlyIf = (newValue === null || newValue === undefined ? undefined : newValue.length) !== (prevValue === null || prevValue === undefined ? undefined : prevValue.length);
-    }
-  }
-  if (isPrim || !newValue || isEmpty(newValue) && !isEmpty(prevValue) ? newValue !== prevValue : hasADiff) {
-    notify(isPrim && isRoot ? node : childNode, newValue, prevValue, (level !== null && level !== undefined ? level : prevValue === undefined) ? -1 : hasADiff ? 0 : 1, whenOptimizedOnlyIf);
-  }
-  endBatch();
-}
-function extractPromise(node, value2) {
-  if (!node.state) {
-    node.state = createObservable({
-      isLoaded: false
-    }, false, getProxy);
-  }
-  value2.then((value3) => {
-    set(node, value3);
-    node.state.isLoaded.set(true);
-  }).catch((error) => {
-    node.state.error.set(error);
-  });
-}
-function extractFunctionOrComputed(node, obj, k, v) {
-  if (isPromise(v)) {
-    extractPromise(getChildNode(node, k), v);
-  } else if (typeof v === "function") {
-    extractFunction(node, k, v);
-  } else if (typeof v == "object" && v !== null && v !== undefined) {
-    const childNode = getNode(v);
-    if (childNode === null || childNode === undefined ? undefined : childNode.isComputed) {
-      extractFunction(node, k, v, childNode);
-      delete obj[k];
-    } else {
-      return true;
-    }
-  }
-}
-function get3(node, options) {
-  const track = options ? isObject2(options) ? options.shallow : options : undefined;
-  updateTracking(node, track);
-  return peek(node);
-}
-function peek(node) {
-  const value2 = getNodeValue(node);
-  if (node.lazy) {
-    delete node.lazy;
-    for (const key in value2) {
-      if (hasOwnProperty.call(value2, key)) {
-        extractFunctionOrComputed(node, value2, key, value2[key]);
-      }
-    }
-  }
-  checkActivate(node);
-  return value2;
-}
-var fns = ["get", "set", "peek", "onChange", "toggle"];
-function ObservablePrimitiveClass(node) {
-  this._node = node;
-  for (let i2 = 0;i2 < fns.length; i2++) {
-    const key = fns[i2];
-    this[key] = this[key].bind(this);
-  }
-}
-function proto(key, fn) {
-  ObservablePrimitiveClass.prototype[key] = function(...args) {
-    return fn.call(this, this._node, ...args);
-  };
-}
-proto("peek", peek);
-proto("get", get3);
-proto("set", set);
-proto("onChange", onChange);
-Object.defineProperty(ObservablePrimitiveClass.prototype, symbolGetNode, {
-  configurable: true,
-  get() {
-    return this._node;
-  }
-});
-ObservablePrimitiveClass.prototype.toggle = function() {
-  const value2 = this.peek();
-  if (value2 === undefined || isBoolean2(value2)) {
-    this.set(!value2);
-  } else if (true) {
-    throw new Error("[legend-state] Cannot toggle a non-boolean value");
-  }
-  return !value2;
-};
-ObservablePrimitiveClass.prototype.delete = function() {
-  this.set(undefined);
-  return this;
-};
-function observable(value2) {
-  return createObservable(value2, false, getProxy, ObservablePrimitiveClass);
-}
-function setupTracking(nodes, update, noArgs, immediate) {
-  let listeners = [];
-  nodes === null || nodes === undefined || nodes.forEach((tracked) => {
-    const { node, track } = tracked;
-    listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
-  });
-  return () => {
-    if (listeners) {
-      for (let i2 = 0;i2 < listeners.length; i2++) {
-        listeners[i2]();
-      }
-      listeners = undefined;
-    }
-  };
-}
-function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
-  var _a;
-  let dispose;
-  let resubscribe;
-  let updateFn = update;
-  beginTracking();
-  const value2 = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === undefined ? undefined : observeOptions.fromComputed) : selector;
-  const tracker = tracking.current;
-  const nodes = tracker.nodes;
-  endTracking();
-  if (tracker && nodes) {
-    (_a = tracker.traceListeners) === null || _a === undefined || _a.call(tracker, nodes);
-    if (tracker.traceUpdates) {
-      updateFn = tracker.traceUpdates(update);
-    }
-    tracker.traceListeners = undefined;
-    tracker.traceUpdates = undefined;
-  }
-  if (!(observeEvent === null || observeEvent === undefined ? undefined : observeEvent.cancel)) {
-    dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === undefined ? undefined : observeOptions.immediate);
-    if (true) {
-      resubscribe = createResubscribe ? () => {
-        dispose === null || dispose === undefined || dispose();
-        dispose = setupTracking(nodes, updateFn);
-        return dispose;
-      } : undefined;
-    }
-  }
-  return { value: value2, dispose, resubscribe };
-}
-function observe(selectorOrRun, reactionOrOptions, options) {
-  let reaction;
-  if (isFunction(reactionOrOptions)) {
-    reaction = reactionOrOptions;
-  } else {
-    options = reactionOrOptions;
-  }
-  let dispose;
-  const e2 = { num: 0 };
-  const update = function() {
-    if (e2.onCleanup) {
-      e2.onCleanup();
-      e2.onCleanup = undefined;
-    }
-    beginBatch();
-    delete e2.value;
-    dispose === null || dispose === undefined || dispose();
-    const { dispose: _dispose, value: value2 } = trackSelector(selectorOrRun, update, e2, options);
-    dispose = _dispose;
-    e2.value = value2;
-    if (e2.onCleanupReaction) {
-      e2.onCleanupReaction();
-      e2.onCleanupReaction = undefined;
-    }
-    endBatch();
-    if (reaction && (e2.num > 0 || !isEvent(selectorOrRun)) && (e2.previous !== e2.value || (options === null || options === undefined ? undefined : options.fromComputed) || typeof e2.value === "object")) {
-      reaction(e2);
-    }
-    e2.previous = e2.value;
-    e2.num++;
-  };
-  update();
-  return () => {
-    var _a, _b;
-    (_a = e2.onCleanup) === null || _a === undefined || _a.call(e2);
-    e2.onCleanup = undefined;
-    (_b = e2.onCleanupReaction) === null || _b === undefined || _b.call(e2);
-    e2.onCleanupReaction = undefined;
-    dispose === null || dispose === undefined || dispose();
-  };
-}
-function computed(compute, set$1) {
-  const obs = observable();
-  lockObservable(obs, true);
-  const node = getNode(obs);
-  node.isComputed = true;
-  let isSetAfterActivated = false;
-  const setInner = function(val) {
-    const prevNode = node.linkedToNode;
-    if (prevNode) {
-      prevNode.linkedFromNodes.delete(node);
-      node.linkedToNode = undefined;
-    }
-    const { parentOther } = node;
-    if (isObservable(val)) {
-      const linkedNode = getNode(val);
-      node.linkedToNode = linkedNode;
-      if (!linkedNode.linkedFromNodes) {
-        linkedNode.linkedFromNodes = new Set;
-      }
-      linkedNode.linkedFromNodes.add(node);
-      if (node.parentOther) {
-        onChange(linkedNode, ({ value: value2 }) => {
-          setNodeValue(node.parentOther, value2);
-        }, { initial: true });
-      }
-      if (prevNode) {
-        const value2 = getNodeValue(linkedNode);
-        const prevValue = getNodeValue(prevNode);
-        notify(node, value2, prevValue, 0);
-      }
-    } else if (val !== obs.peek()) {
-      lockObservable(obs, false);
-      const setter = isSetAfterActivated ? set : setNodeValue;
-      setter(node, val);
-      if (parentOther) {
-        let didUnlock = false;
-        if (parentOther.root.locked) {
-          parentOther.root.locked = false;
-          didUnlock = true;
-        }
-        setter(parentOther, val);
-        if (didUnlock) {
-          parentOther.root.locked = true;
-        }
-      }
-      lockObservable(obs, true);
-    } else if (parentOther) {
-      setNodeValue(parentOther, val);
-    }
-    isSetAfterActivated = true;
-  };
-  node.root.activate = () => {
-    node.root.activate = undefined;
-    observe(compute, ({ value: value2 }) => {
-      if (isPromise(value2)) {
-        value2.then((v) => setInner(v));
-      } else {
-        setInner(value2);
-      }
-    }, { immediate: true, fromComputed: true });
-  };
-  if (set$1) {
-    node.root.set = (value2) => {
-      batch2(() => set$1(value2));
-    };
-  }
-  return obs;
+  return result;
 }
 
-// src/exchanges/paper/engine.ts
-function generateSummary2({
-  trades = [],
-  fee_percent = 0.05,
-  anchor
-}) {
-  if (trades.length === 0) {
-    return {};
+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;
   }
-  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();
-}
-function preComputePositionState({
-  position: position2,
-  trades,
-  fee_percent = 0,
-  entry_fees = 0,
-  global_config: symbol_config
-}) {
-  const state = observable({
-    position: position2,
-    trades,
-    take_profit: null,
-    stop_loss: null,
-    newTrades: () => {
-      const tradesList = state.trades.get();
-      const pos = state.position.get();
-      if (!tradesList || tradesList.length === 0) {
-        return [];
-      }
-      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, symbol_config.price_places) : 0;
-        const avg_size = to_f(cumulativeQty, symbol_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, symbol_config.price_places);
-        return {
-          ...trade,
-          avg_entry,
-          avg_size,
-          neg_pnl
-        };
-      });
-      return processedTrades.reverse();
-    },
-    generateSummary() {
-      const trades2 = state.newTrades();
-      return {
-        ...generateSummary2({
-          trades: trades2,
-          fee_percent
-        }),
-        entry_fees: to_f(entry_fees, "%.2f")
-      };
-    },
-    summary: computed(() => {
-      const trades2 = state.newTrades();
-      return {
-        ...generateSummary2({
-          trades: trades2,
-          fee_percent
-        }),
-        entry_fees: to_f(entry_fees, "%.2f")
-      };
-    }),
-    positionAt(price) {
-      const trades2 = state.newTrades();
-      const kind = state.position.get().kind;
-      const filtered = trades2.filter((trade) => {
-        if (kind === "long") {
-          return trade.entry >= price;
-        }
-        return trade.entry <= price;
-      });
-      return filtered[0];
-    },
-    newPositionState(price) {
-      const position3 = state.position.get();
-      const trades2 = state.newTrades();
-      const instance = state.positionAt(price);
-      return positionAt({
+  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: {
-          ...position3,
-          entry: instance.avg_entry,
-          quantity: instance.avg_size
+          kind,
+          entry: 0,
+          quantity: 0
         },
-        trades: trades2,
-        global_config: symbol_config
-      });
-    },
-    updateTakeProfit({
-      entry,
-      quantity
-    }) {
-      state.take_profit.set({
-        price: entry,
-        quantity: quantity || state.position.get().quantity
-      });
-    },
-    updateStopLoss(payload) {
-      const { stop, quantity } = payload || {
-        stop: state.newTrades()[0].entry,
-        quantity: state.summary.get().quantity
-      };
-      state.stop_loss.set({
-        price: stop,
-        quantity
+        global_config: this.global_config,
+        trades,
+        as_state: false
       });
-    }
-  });
-  return state;
-}
-function determineNewPosition({
-  position: position2,
-  price,
-  trades,
-  global_config
-}) {
-  const kind = position2.kind;
-  const placed = trades.filter((t2) => {
-    if (kind === "long") {
-      return t2.entry >= price;
-    }
-    return t2.entry <= price;
-  });
-  const placeQty = placed.reduce((acc, trade) => acc + trade.quantity, 0);
-  if (position2.quantity > 0) {
-    const placed_less_than_entry = placed.filter((t2) => {
-      if (kind === "long") {
-        return t2.entry < position2.entry;
-      }
-      return t2.entry > position2.entry;
+      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
     });
-    const avg = determine_average_entry_and_size(placed_less_than_entry.map((o) => ({
-      price: o.entry,
-      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) => {
-    if (kind === "long") {
-      return t2.entry >= price;
-    }
-    return t2.entry <= price;
-  });
-  const not_placed = trades.filter((t2) => {
-    if (kind === "long") {
-      return t2.entry < price;
+  initializeEngine({
+    price,
+    dangerous,
+    trades,
+    config: config2
+  }) {
+    if (config2) {
+      this.generateShortTrades(config2);
     }
-    return t2.entry > price;
-  });
-  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 },
+    return this.positionAt({
       price,
+      dangerous,
       trades
-    }),
-    entry_fees: fee,
-    fee_percent: fee_rate.maker,
-    global_config
-  };
-  if (as_state) {
-    const derivedState = preComputePositionState(result);
-    return derivedState;
+    });
   }
-  return result;
-}
-function primitiveTradeGenerator({
-  global_config,
-  position: position2 = { entry: 0, quantity: 0, kind: "long" }
-}) {
-  const state = observable({
-    trade_details: null,
-    async generateShortTrades(config2) {
-      const result = compoundAPI.buildWithOptimumReward({
-        global_config,
-        config: config2,
-        settings: config2,
-        use_default: true
-      });
-      state.trade_details.set(result);
-    },
-    async generateAllTrades(config2) {
-      await Promise.allSettled([state.generateShortTrades(config2)]);
-    },
-    positionAt({
-      price,
-      dangerous,
-      trades: existingTrades
-    }) {
-      const trades = existingTrades || state.trade_details.get()?.trades || [];
-      if (dangerous) {
-        const kind = position2.kind;
-        const naive_assumptions = positionAt({
-          price,
-          position: {
-            kind,
-            entry: 0,
-            quantity: 0
-          },
-          global_config,
-          trades,
-          as_state: false
-        });
-        const avg_position = determine_average_entry_and_size([
-          {
-            price: position2.entry,
-            quantity: position2.quantity
-          },
-          {
-            price: naive_assumptions.position.entry,
-            quantity: naive_assumptions.position.quantity
-          }
-        ], global_config.decimal_places, global_config.price_places);
-        const new_position = dangerous ? {
-          ...position2,
-          entry: avg_position.entry,
-          quantity: avg_position.quantity
-        } : position2;
-        return preComputePositionState({
-          ...naive_assumptions,
-          trades: naive_assumptions.trades,
-          position: new_position,
-          global_config
-        });
-      }
-      const _trades = existingTrades || cumulativeHelper({
-        tradesList: trades,
-        decimal_places: global_config.decimal_places
-      }).filter((o) => o.cumulative_size > position2.quantity);
-      return positionAt({
-        price,
-        position: position2,
-        trades: _trades,
-        global_config
-      });
-    },
-    async initializeEngine({
-      price,
-      dangerous,
-      trades,
-      config: config2
-    }) {
-      if (config2) {
-        await state.generateAllTrades(config2);
-      }
-      return state.positionAt({
-        price,
-        dangerous,
-        trades
-      });
-    }
-  });
-  return state;
 }
 function transformTradesToExchangeType({
   trades,
-  kind,
   take_profit,
-  stop_loss
+  stop_loss,
+  kind
 }) {
   const currentTime = Date.now();
   const result = [];
@@ -60623,7 +59464,7 @@ function transformTradesToExchangeType({
     });
   });
   let nextOrderId = trades.length;
-  if (take_profit) {
+  if (take_profit && take_profit.quantity > 0) {
     const tpSide = kind === "long" ? "sell" : "buy";
     const tpPositionSide = kind.toUpperCase();
     result.push({
@@ -60663,7 +59504,7 @@ function transformTradesToExchangeType({
     });
     nextOrderId++;
   }
-  if (stop_loss) {
+  if (stop_loss && stop_loss.quantity > 0) {
     const slSide = kind === "long" ? "sell" : "buy";
     const slPositionSide = kind.toUpperCase();
     result.push({
@@ -60712,8 +59553,8 @@ function isTakeProfitOrder(order) {
 }
 function transformExchangeOrderToTradeWithValidation(orders, options) {
   const {
-    validateQuantity = true,
     validatePrice = true,
+    validateQuantity = true,
     defaultStop = 0
   } = options || {};
   const trades = [];
@@ -60762,6 +59603,72 @@ function transformExchangeOrderToTradeWithValidation(orders, options) {
     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) {
@@ -60998,6 +59905,7 @@ async function savePaperDetails(client, payload, 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
@@ -61040,6 +59948,30 @@ async function fetchDBExchangeData(client, symbol) {
     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;
+    if (["tp", "sl"].includes(long_result.changed)) {
+      config2.long = null;
+    }
+    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,
@@ -61047,12 +59979,13 @@ async function fetchDBExchangeData(client, symbol) {
     positions,
     current_price,
     config: config2,
+    trades,
     raw_data: live_exchange_details?.data
   };
 }
 async function getPositionInfo3(client, symbol) {
-  const { positions, symbol_config, current_price, orders, config: config2, raw_data } = await fetchDBExchangeData(client, symbol);
-  const long_generator = primitiveTradeGenerator({
+  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,
@@ -61060,7 +59993,7 @@ async function getPositionInfo3(client, symbol) {
     },
     global_config: symbol_config
   });
-  const short_generator = primitiveTradeGenerator({
+  const short_generator = new TradeEngine({
     position: {
       kind: "short",
       entry: positions.short?.entry || 0,
@@ -61068,36 +60001,75 @@ async function getPositionInfo3(client, symbol) {
     },
     global_config: symbol_config
   });
-  const long_trades = transformExchangeOrderToTradeWithValidation(orders.filter((o) => o.positionSide.toLowerCase() === "long"), { validatePrice: false, validateQuantity: false });
-  const short_trades = transformExchangeOrderToTradeWithValidation(orders.filter((o) => o.positionSide.toLowerCase() === "short"), { validatePrice: false, validateQuantity: false });
-  const long_state = await long_generator.initializeEngine({
-    trades: config2.long ? undefined : long_trades.trades,
-    config: config2.long,
+  const long_state = long_generator.initializeEngine({
+    trades: trades.long,
     price: current_price
   });
-  const short_state = await short_generator.initializeEngine({
-    trades: config2.short ? undefined : short_trades.trades,
-    config: config2.short,
+  const short_state = short_generator.initializeEngine({
+    trades: trades.short,
     price: current_price
   });
   if (raw_data) {
-    await updateDbDetails(client, {
-      kind: "long",
-      symbol
-    }, raw_data, {
-      position: {},
-      orders: long_state.newTrades()
-    });
-    await updateDbDetails(client, {
-      kind: "short",
-      symbol
-    }, raw_data, {
-      position: {},
-      orders: short_state.newTrades()
-    });
+    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.get();
-  const short_position = short_state.position.get();
+  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 = {
@@ -61320,7 +60292,11 @@ async function placeTpOrder3(client, payload) {
 }
 async function cancelAllOrders3(client, symbol, payload) {
   const { type, side, kind } = payload;
-  const { orders: fullOrders, symbol_config } = await fetchDBExchangeData(client, symbol);
+  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);
@@ -61331,9 +60307,13 @@ async function cancelAllOrders3(client, symbol, payload) {
     decimal_places: symbol_config.decimal_places,
     price_places: symbol_config.price_places
   }, {
-    position: {},
+    position: positions[kind] || {},
     orders: excludeFromSameKind,
-    raw: true
+    raw: true,
+    stop_loss: {
+      price: 0,
+      quantity: 0
+    }
   });
 }
 async function cancelOrdersParallel2(payload) {
@@ -61370,6 +60350,49 @@ async function cancelOrders3(payload) {
     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) {
@@ -61387,36 +60410,7 @@ class PaperBinanceExchange extends BaseExchange {
     return await cancelAllOrders3(this.client, symbol, payload);
   }
   async _createLimitPurchaseOrders(payload) {
-    const { positions, symbol_config, current_price, config: config2 } = await fetchDBExchangeData(this.client, payload.symbol);
-    const kind = payload.orders[0].kind;
-    const params = {
-      position: {
-        kind,
-        entry: positions[kind]?.entry || 0,
-        quantity: positions[kind]?.quantity || 0
-      },
-      global_config: symbol_config
-    };
-    const generator = primitiveTradeGenerator(params);
-    const state = await generator.initializeEngine({
-      config: config2[kind],
-      trades: payload.orders,
-      price: current_price
-    });
-    const current_position_state = {
-      entry: state.position.get().entry,
-      quantity: state.position.get().quantity
-    };
-    const remaining_orders = state.newTrades();
-    return await savePaperDetails(this.client, {
-      kind,
-      symbol: payload.symbol,
-      price_places: payload.price_places,
-      decimal_places: payload.decimal_places
-    }, {
-      position: current_position_state,
-      orders: remaining_orders
-    });
+    return await createLimitPurchaseOrders2(this.client, payload);
   }
   async analyzeCharts(_payload) {}
   async getExchangeInfo(options) {
@@ -61496,9 +60490,10 @@ class PaperBinanceExchange extends BaseExchange {
       symbol_config,
       current_price,
       orders: _orders,
+      trades,
       config: config2
     } = await fetchDBExchangeData(this.client, _payload.symbol);
-    const generator = primitiveTradeGenerator({
+    const generator = new TradeEngine({
       position: {
         kind,
         entry: positions[kind]?.entry || 0,
@@ -61506,9 +60501,10 @@ class PaperBinanceExchange extends BaseExchange {
       },
       global_config: symbol_config
     });
-    const long_state = await generator.initializeEngine({
+    const long_state = generator.initializeEngine({
       config: config2[kind],
-      price: current_price
+      price: current_price,
+      trades: trades.long
     });
     return long_state;
   }
@@ -61534,6 +60530,14 @@ async function forceClosePosition2(client, symbol, options) {
       entry: 0,
       quantity: 0
     },
+    take_profit: {
+      price: 0,
+      quantity: 0
+    },
+    stop_loss: {
+      price: 0,
+      quantity: 0
+    },
     orders: []
   });
 }