@orderly.network/hooks 1.3.2 → 1.4.0-alpha.1

package/lib/orderly/{useOrderStream.d.ts → useOrderStream/useOrderStream.d.ts}

@@ -1,17 +1,21 @@
-import { OrderSide, OrderEntity, OrderStatus } from "@orderly.network/types";
-export interface UserOrdersReturn {
-    data: any[];
-    loading: boolean;
-    update: (order: any) => void;
-    cancel: (order: any) => void;
-}
-type Params = {
+import { OrderSide, OrderEntity, OrderStatus, API, AlgoOrderRootType } from "@orderly.network/types";
+type CombineOrderType = AlgoOrderRootType | "ALL";
+export declare const useOrderStream: (params: {
     symbol?: string;
     status?: OrderStatus;
     size?: number;
     side?: OrderSide;
-};
-export declare const useOrderStream: (params: Params, options?: {
+    /**
+     * Include the order type
+     * @default ["ALL"]
+     */
+    includes?: CombineOrderType[];
+    /**
+     * Exclude the order type
+     * @default []
+     */
+    excludes?: CombineOrderType[];
+}, options?: {
     /**
      * Keep the state update alive
      */
@@ -21,15 +25,19 @@ export declare const useOrderStream: (params: Params, options?: {
      */
     stopOnUnmount?: boolean;
 }) => readonly [any[] | null, {
-    readonly total: any;
+    readonly total: number;
     readonly isLoading: boolean;
     readonly refresh: import("swr/_internal").KeyedMutator<any[]>;
     readonly loadMore: () => void;
-    readonly cancelAllOrders: () => void;
+    readonly cancelAllOrders: () => Promise<[any, any]>;
+    readonly cancelAllTPSLOrders: () => Promise<any[]>;
+    readonly cancelAlgoOrdersByTypes: (types: AlgoOrderRootType[]) => Promise<any[]>;
     readonly updateOrder: (orderId: string, order: OrderEntity) => Promise<any>;
     readonly cancelOrder: (orderId: number, symbol?: string) => Promise<any>;
     readonly updateAlgoOrder: (orderId: string, order: OrderEntity) => Promise<any>;
     readonly cancelAlgoOrder: (orderId: number, symbol?: string) => Promise<any>;
+    readonly cancelTPSLChildOrder: (orderId: number, rootAlgoOrderId: number) => Promise<any>;
+    readonly updateTPSLOrder: (orderId: number, childOrders: API.AlgoOrder["child_orders"]) => Promise<any>;
     readonly errors: {
         readonly cancelOrder: unknown;
         readonly updateOrder: unknown;

package/lib/orderly/useOrderStream/useOrderStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOrderStream.d.ts","sourceRoot":"","sources":["../../../src/orderly/useOrderStream/useOrderStream.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,SAAS,EACT,WAAW,EACX,WAAW,EACX,GAAG,EACH,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAYhC,KAAK,gBAAgB,GAAG,iBAAiB,GAAG,KAAK,CAAC;AAElD,eAAO,MAAM,cAAc,WAIjB;IACN,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC/B,YACS;IACR;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;;;;;;;8CAmIuC,iBAAiB,EAAE;oCAuDjB,MAAM,SAAS,WAAW;oCAoD1B,MAAM,WAAW,MAAM;wCA7CnB,MAAM,SAAS,WAAW;wCAoD1B,MAAM,WAAW,MAAM;6CAazD,MAAM,mBAAmB,MAAM,KAAG,QAAQ,GAAG,CAAC;wCAmB7C,MAAM,eACF,IAAI,SAAS,CAAC,cAAc,CAAC;;;;;;;;;;;;;EA2C/C,CAAC"}

package/lib/orderly/{useOrderStream.js → useOrderStream/useOrderStream.js}

@@ -8,15 +8,14 @@ Object.defineProperty(exports, "useOrderStream", {
         return useOrderStream;
     }
 });
-const _usePrivateInfiniteQuery = require("../usePrivateInfiniteQuery");
+const _usePrivateInfiniteQuery = require("../../usePrivateInfiniteQuery");
 const _react = require("react");
 const _types = require("@orderly.network/types");
-const _useMarkPricesStream = require("./useMarkPricesStream");
-const _useMutation = require("../useMutation");
-const _version = /*#__PURE__*/ _interop_require_default(require("../version"));
-const _dataProvider = require("../dataProvider");
-const _swr = require("../utils/swr");
-const _useEventEmitter = require("../useEventEmitter");
+const _useMarkPricesStream = require("../useMarkPricesStream");
+const _useMutation = require("../../useMutation");
+const _version = /*#__PURE__*/ _interop_require_default(require("../../version"));
+const _dataProvider = require("../../dataProvider");
+const _swr = require("../../utils/swr");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -25,13 +24,16 @@ function _interop_require_default(obj) {
 const useOrderStream = (/**
    * Orders query params
    */ params, options)=>{
-    const { status, symbol, side, size = 100 } = params;
+    const { status, symbol, side, size = 100, includes = [
+        "ALL"
+    ], excludes = [] } = params;
     const { data: markPrices = {} } = (0, _useMarkPricesStream.useMarkPricesStream)();
-    const ee = (0, _useEventEmitter.useEventEmitter)();
     const { regesterKeyHandler, unregisterKeyHandler } = (0, _dataProvider.useDataCenterContext)();
     const [doCancelOrder, { error: cancelOrderError, isMutating: cancelMutating }] = (0, _useMutation.useMutation)("/v1/order", "DELETE");
+    const [doCancelAllOrders] = (0, _useMutation.useMutation)("/v1/orders", "DELETE");
     const [doUpdateOrder, { error: updateOrderError, isMutating: updateMutating }] = (0, _useMutation.useMutation)("/v1/order", "PUT");
     const [doCanceAlgolOrder, { error: cancelAlgoOrderError, isMutating: cancelAlgoMutating }] = (0, _useMutation.useMutation)("/v1/algo/order", "DELETE");
+    const [doCancelAllAlgoOrders] = (0, _useMutation.useMutation)("/v1/algo/orders", "DELETE");
     const [doUpdateAlgoOrder, { error: updateAlgoOrderError, isMutating: updateAlgoMutating }] = (0, _useMutation.useMutation)("/v1/algo/order", "PUT");
     (0, _react.useEffect)(()=>{
         const formatKey = (value)=>value ? `:${value}` : "";
@@ -70,9 +72,25 @@ const useOrderStream = (/**
         if (!ordersResponse.data) {
             return null;
         }
-        return ordersResponse.data?.map((item)=>item.rows)?.flat();
+        let orders = ordersResponse.data?.map((item)=>item.rows)?.flat();
+        // return ordersResponse.data?.map((item) => item.rows)?.flat();
+        if (includes.includes("ALL") && excludes.length === 0) {
+            return orders;
+        }
+        if (includes.includes("ALL") && excludes.length > 0) {
+            return orders?.filter((item)=>!excludes.includes(item.algo_type));
+        }
+        if (includes.length > 0 && excludes.length === 0) {
+            return orders?.filter((item)=>includes.includes(item.algo_type));
+        }
+        if (includes.length > 0 && excludes.length > 0) {
+            return orders?.filter((item)=>includes.includes(item.algo_type) && !excludes.includes(item.algo_type));
+        }
+        return orders;
     }, [
-        ordersResponse.data
+        ordersResponse.data,
+        includes,
+        excludes
     ]);
     // console.log(ordersResponse.data);
     const orders = (0, _react.useMemo)(()=>{
@@ -83,10 +101,17 @@ const useOrderStream = (/**
             return flattenOrders;
         }
         return flattenOrders.map((item)=>{
-            return {
+            const order = {
                 ...item,
                 mark_price: markPrices[item.symbol] ?? 0
             };
+            ///TODO: remove this when BE provides the correct data
+            // console.log("------------->>>>>>>>", order);
+            if (order.algo_type === _types.AlgoOrderRootType.POSITIONAL_TP_SL || order.algo_type === _types.AlgoOrderRootType.TP_SL) {
+                order.quantity = order.child_orders[0].quantity;
+            }
+            ///-----------------todo end----------------
+            return order;
         });
     }, [
         flattenOrders,
@@ -94,13 +119,43 @@ const useOrderStream = (/**
         status
     ]);
     const total = (0, _react.useMemo)(()=>{
-        return ordersResponse.data?.[0]?.meta?.total || 0;
+        return orders?.length || 0;
+    // return ordersResponse.data?.[0]?.meta?.total || 0;
     }, [
-        ordersResponse.data?.[0]?.meta?.total
+        orders?.length
     ]);
+    const cancelAlgoOrdersByTypes = (types)=>{
+        if (!types) {
+            throw new _types.SDKError("types is required");
+        }
+        if (!Array.isArray(types)) {
+            throw new _types.SDKError("types should be an array");
+        }
+        // TODO: order type check
+        return Promise.all(types.map((type)=>{
+            return doCancelAllAlgoOrders(null, {
+                algo_type: type
+            });
+        }));
+    };
     /**
    * cancel all orders
-   */ const cancelAllOrders = (0, _react.useCallback)(()=>{}, [
+   */ const cancelAllOrders = (0, _react.useCallback)(()=>{
+        return Promise.all([
+            doCancelAllOrders(null),
+            doCancelAllAlgoOrders(null, {
+                algo_type: "STOP"
+            })
+        ]);
+    }, [
+        ordersResponse.data
+    ]);
+    const cancelAllTPSLOrders = (0, _react.useCallback)(()=>{
+        return cancelAlgoOrdersByTypes([
+            _types.AlgoOrderRootType.POSITIONAL_TP_SL,
+            _types.AlgoOrderRootType.TP_SL
+        ]);
+    }, [
         ordersResponse.data
     ]);
     const _updateOrder = (0, _react.useCallback)((orderId, order, type)=>{
@@ -127,16 +182,7 @@ const useOrderStream = (/**
     /**
    * update algo order
    */ const updateAlgoOrder = (0, _react.useCallback)((orderId, order)=>{
-        return _updateOrder(orderId, order, "algoOrder").then((res)=>{
-            // TODO: remove this when the WS service provides the correct data
-            ee.emit("algoOrder:cache", {
-                // ...res.data.rows[0],
-                ...order,
-                order_id: Number(orderId)
-            });
-            //------------fix end----------------
-            return res;
-        });
+        return _updateOrder(orderId, order, "algoOrder");
     }, []);
     const _cancelOrder = (0, _react.useCallback)((orderId, type, symbol)=>{
         switch(type){
@@ -186,6 +232,31 @@ const useOrderStream = (/**
     const loadMore = ()=>{
         ordersResponse.setSize(ordersResponse.size + 1);
     };
+    // const cancelTPSLOrder = useCallback((orderId:number, symbol:string)=>{
+    //   return
+    // });
+    const cancelTPSLChildOrder = (0, _react.useCallback)((orderId, rootAlgoOrderId)=>{
+        return doUpdateAlgoOrder({
+            order_id: rootAlgoOrderId,
+            child_orders: [
+                {
+                    order_id: orderId,
+                    is_activated: false
+                }
+            ]
+        });
+    }, []);
+    const updateTPSLOrder = (0, _react.useCallback)((/**
+       * the root algo order id
+       */ orderId, childOrders)=>{
+        if (!Array.isArray(childOrders)) {
+            throw new _types.SDKError("children orders is required");
+        }
+        return doUpdateAlgoOrder({
+            order_id: orderId,
+            child_orders: childOrders
+        });
+    }, []);
     return [
         orders,
         {
@@ -194,10 +265,14 @@ const useOrderStream = (/**
             refresh: ordersResponse.mutate,
             loadMore,
             cancelAllOrders,
+            cancelAllTPSLOrders,
+            cancelAlgoOrdersByTypes,
             updateOrder,
             cancelOrder,
             updateAlgoOrder,
             cancelAlgoOrder,
+            cancelTPSLChildOrder,
+            updateTPSLOrder,
             errors: {
                 cancelOrder: cancelOrderError,
                 updateOrder: updateOrderError,

package/lib/orderly/useOrderStream/useOrderStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/orderly/useOrderStream/useOrderStream.ts"],"sourcesContent":["import { usePrivateInfiniteQuery } from \"../../usePrivateInfiniteQuery\";\nimport { useCallback, useEffect, useMemo } from \"react\";\nimport {\n  OrderSide,\n  OrderEntity,\n  OrderStatus,\n  API,\n  AlgoOrderRootType,\n} from \"@orderly.network/types\";\nimport { useMarkPricesStream } from \"../useMarkPricesStream\";\nimport { useMutation } from \"../../useMutation\";\nimport version from \"../../version\";\nimport { useDataCenterContext } from \"../../dataProvider\";\nimport { generateKeyFun } from \"../../utils/swr\";\nimport { useEventEmitter } from \"../../useEventEmitter\";\nimport { SDKError } from \"@orderly.network/types\";\nimport { AlgoOrderType } from \"@orderly.network/types\";\n\ntype CreateOrderType = \"normalOrder\" | \"algoOrder\";\n\ntype CombineOrderType = AlgoOrderRootType | \"ALL\";\n\nexport const useOrderStream = (\n  /**\n   * Orders query params\n   */\n  params: {\n    symbol?: string;\n    status?: OrderStatus;\n    size?: number;\n    side?: OrderSide;\n    /**\n     * Include the order type\n     * @default [\"ALL\"]\n     */\n    includes?: CombineOrderType[];\n    /**\n     * Exclude the order type\n     * @default []\n     */\n    excludes?: CombineOrderType[];\n  },\n  options?: {\n    /**\n     * Keep the state update alive\n     */\n    keeplive?: boolean;\n    /**\n     * Stop the state update when the component unmount\n     */\n    stopOnUnmount?: boolean;\n  }\n) => {\n  const {\n    status,\n    symbol,\n    side,\n    size = 100,\n    includes = [\"ALL\"],\n    excludes = [],\n  } = params;\n\n  const { data: markPrices = {} } = useMarkPricesStream();\n\n  const { regesterKeyHandler, unregisterKeyHandler } = useDataCenterContext();\n  const [\n    doCancelOrder,\n    { error: cancelOrderError, isMutating: cancelMutating },\n  ] = useMutation(\"/v1/order\", \"DELETE\");\n\n  const [doCancelAllOrders] = useMutation(\"/v1/orders\", \"DELETE\");\n\n  const [\n    doUpdateOrder,\n    { error: updateOrderError, isMutating: updateMutating },\n  ] = useMutation(\"/v1/order\", \"PUT\");\n\n  const [\n    doCanceAlgolOrder,\n    { error: cancelAlgoOrderError, isMutating: cancelAlgoMutating },\n  ] = useMutation(\"/v1/algo/order\", \"DELETE\");\n\n  const [doCancelAllAlgoOrders] = useMutation(\"/v1/algo/orders\", \"DELETE\");\n\n  const [\n    doUpdateAlgoOrder,\n    { error: updateAlgoOrderError, isMutating: updateAlgoMutating },\n  ] = useMutation(\"/v1/algo/order\", \"PUT\");\n\n  useEffect(() => {\n    const formatKey = (value?: string) => (value ? `:${value}` : \"\");\n    const key = `orders${formatKey(status)}${formatKey(symbol)}${formatKey(\n      side\n    )}`;\n    regesterKeyHandler?.(key, generateKeyFun({ status, symbol, side, size }));\n\n    return () => {\n      if (!options?.stopOnUnmount) return;\n\n      unregisterKeyHandler(key);\n    };\n  }, [status, symbol, side, options?.keeplive]);\n\n  const ordersResponse = usePrivateInfiniteQuery(\n    generateKeyFun({ status, symbol, side, size }),\n    {\n      initialSize: 1,\n      // revalidateFirstPage: false,\n      // onError: (err) => {\n      //   console.error(\"fetch failed::::\", err);\n      // },\n      formatter: (data) => data,\n      revalidateOnFocus: false,\n    }\n  );\n\n  const flattenOrders = useMemo(() => {\n    if (!ordersResponse.data) {\n      return null;\n    }\n    let orders = ordersResponse.data?.map((item) => item.rows)?.flat();\n\n    // return ordersResponse.data?.map((item) => item.rows)?.flat();\n\n    if (includes.includes(\"ALL\") && excludes.length === 0) {\n      return orders;\n    }\n\n    if (includes.includes(\"ALL\") && excludes.length > 0) {\n      return orders?.filter((item) => !excludes.includes(item.algo_type));\n    }\n\n    if (includes.length > 0 && excludes.length === 0) {\n      return orders?.filter((item) => includes.includes(item.algo_type));\n    }\n\n    if (includes.length > 0 && excludes.length > 0) {\n      return orders?.filter(\n        (item) =>\n          includes.includes(item.algo_type) &&\n          !excludes.includes(item.algo_type)\n      );\n    }\n\n    return orders;\n  }, [ordersResponse.data, includes, excludes]);\n\n  // console.log(ordersResponse.data);\n\n  const orders = useMemo(() => {\n    if (!flattenOrders) {\n      return null;\n    }\n\n    if (status !== OrderStatus.NEW && status !== OrderStatus.INCOMPLETE) {\n      return flattenOrders;\n    }\n    return flattenOrders.map((item) => {\n      const order = {\n        ...item,\n        mark_price: (markPrices as any)[item.symbol] ?? 0,\n      };\n\n      ///TODO: remove this when BE provides the correct data\n      // console.log(\"------------->>>>>>>>\", order);\n      if (\n        order.algo_type === AlgoOrderRootType.POSITIONAL_TP_SL ||\n        order.algo_type === AlgoOrderRootType.TP_SL\n      ) {\n        order.quantity = order.child_orders[0].quantity;\n      }\n      ///-----------------todo end----------------\n\n      return order;\n    });\n  }, [flattenOrders, markPrices, status]);\n\n  const total = useMemo(() => {\n    return orders?.length || 0;\n    // return ordersResponse.data?.[0]?.meta?.total || 0;\n  }, [orders?.length]);\n\n  const cancelAlgoOrdersByTypes = (types: AlgoOrderRootType[]) => {\n    if (!types) {\n      throw new SDKError(\"types is required\");\n    }\n\n    if (!Array.isArray(types)) {\n      throw new SDKError(\"types should be an array\");\n    }\n\n    // TODO: order type check\n\n    return Promise.all(\n      types.map((type) => {\n        return doCancelAllAlgoOrders(null, { algo_type: type });\n      })\n    );\n  };\n\n  /**\n   * cancel all orders\n   */\n  const cancelAllOrders = useCallback(() => {\n    return Promise.all([\n      doCancelAllOrders(null),\n      doCancelAllAlgoOrders(null, { algo_type: \"STOP\" }),\n    ]);\n  }, [ordersResponse.data]);\n\n  const cancelAllTPSLOrders = useCallback(() => {\n    return cancelAlgoOrdersByTypes([\n      AlgoOrderRootType.POSITIONAL_TP_SL,\n      AlgoOrderRootType.TP_SL,\n    ]);\n  }, [ordersResponse.data]);\n\n  const _updateOrder = useCallback(\n    (orderId: string, order: OrderEntity, type: CreateOrderType) => {\n      switch (type) {\n        case \"algoOrder\":\n          return doUpdateAlgoOrder({\n            order_id: orderId,\n            price: order[\"order_price\"],\n            quantity: order[\"order_quantity\"],\n            trigger_price: order[\"trigger_price\"],\n          });\n        default:\n          return doUpdateOrder({ ...order, order_id: orderId });\n      }\n    },\n    []\n  );\n\n  /**\n   * update order\n   */\n  const updateOrder = useCallback((orderId: string, order: OrderEntity) => {\n    return _updateOrder(orderId, order, \"normalOrder\");\n  }, []);\n\n  /**\n   * update algo order\n   */\n  const updateAlgoOrder = useCallback((orderId: string, order: OrderEntity) => {\n    return _updateOrder(orderId, order, \"algoOrder\");\n  }, []);\n\n  const _cancelOrder = useCallback(\n    (orderId: number, type: CreateOrderType, symbol?: string) => {\n      switch (type) {\n        case \"algoOrder\":\n          return doCanceAlgolOrder(null, {\n            // @ts-ignore\n            order_id: orderId,\n            symbol,\n            source: `SDK${version}`,\n          }).then((res: any) => {\n            if (res.success) {\n              ordersResponse.mutate();\n              return res;\n            } else {\n              throw new Error(res.message);\n            }\n          });\n        default:\n          return doCancelOrder(null, {\n            order_id: orderId,\n            symbol,\n            source: `SDK_${version}`,\n          }).then((res: any) => {\n            if (res.success) {\n              // return ordersResponse.mutate().then(() => {\n              //   return res;\n              // });\n              //Optimistic Updates\n              // ordersResponse.mutate();\n              return res;\n            } else {\n              throw new Error(res.message);\n            }\n          });\n      }\n    },\n    []\n  );\n  /**\n   * calcel order\n   */\n  const cancelOrder = useCallback((orderId: number, symbol?: string) => {\n    return _cancelOrder(orderId, \"normalOrder\", symbol);\n  }, []);\n\n  /**\n   * calcel algo order\n   */\n  const cancelAlgoOrder = useCallback((orderId: number, symbol?: string) => {\n    return _cancelOrder(orderId, \"algoOrder\", symbol);\n  }, []);\n\n  const loadMore = () => {\n    ordersResponse.setSize(ordersResponse.size + 1);\n  };\n\n  // const cancelTPSLOrder = useCallback((orderId:number, symbol:string)=>{\n  //   return\n  // });\n\n  const cancelTPSLChildOrder = useCallback(\n    (orderId: number, rootAlgoOrderId: number): Promise<any> => {\n      return doUpdateAlgoOrder({\n        order_id: rootAlgoOrderId,\n        child_orders: [\n          {\n            order_id: orderId,\n            is_activated: false,\n          },\n        ],\n      });\n    },\n    []\n  );\n\n  const updateTPSLOrder = useCallback(\n    (\n      /**\n       * the root algo order id\n       */\n      orderId: number,\n      childOrders: API.AlgoOrder[\"child_orders\"]\n    ) => {\n      if (!Array.isArray(childOrders)) {\n        throw new SDKError(\"children orders is required\");\n      }\n      return doUpdateAlgoOrder({\n        order_id: orderId,\n        child_orders: childOrders,\n      });\n    },\n    []\n  );\n\n  return [\n    orders,\n    {\n      total,\n      isLoading: ordersResponse.isLoading,\n      refresh: ordersResponse.mutate,\n      loadMore,\n      cancelAllOrders,\n      cancelAllTPSLOrders,\n      cancelAlgoOrdersByTypes,\n      updateOrder,\n      cancelOrder,\n      updateAlgoOrder,\n      cancelAlgoOrder,\n      cancelTPSLChildOrder,\n      updateTPSLOrder,\n      errors: {\n        cancelOrder: cancelOrderError,\n        updateOrder: updateOrderError,\n        cancelAlgoOrder: cancelAlgoOrderError,\n        updateAlgoOrder: updateAlgoOrderError,\n      },\n      submitting: {\n        cancelOrder: cancelMutating,\n        updateOrder: updateMutating,\n        cancelAlgoOrder: cancelAlgoMutating,\n        updateAlglOrder: updateAlgoMutating,\n      },\n    },\n  ] as const;\n};\n"],"names":["useOrderStream","params","options","status","symbol","side","size","includes","excludes","data","markPrices","useMarkPricesStream","regesterKeyHandler","unregisterKeyHandler","useDataCenterContext","doCancelOrder","error","cancelOrderError","isMutating","cancelMutating","useMutation","doCancelAllOrders","doUpdateOrder","updateOrderError","updateMutating","doCanceAlgolOrder","cancelAlgoOrderError","cancelAlgoMutating","doCancelAllAlgoOrders","doUpdateAlgoOrder","updateAlgoOrderError","updateAlgoMutating","useEffect","formatKey","value","key","generateKeyFun","stopOnUnmount","keeplive","ordersResponse","usePrivateInfiniteQuery","initialSize","formatter","revalidateOnFocus","flattenOrders","useMemo","orders","map","item","rows","flat","length","filter","algo_type","OrderStatus","NEW","INCOMPLETE","order","mark_price","AlgoOrderRootType","POSITIONAL_TP_SL","TP_SL","quantity","child_orders","total","cancelAlgoOrdersByTypes","types","SDKError","Array","isArray","Promise","all","type","cancelAllOrders","useCallback","cancelAllTPSLOrders","_updateOrder","orderId","order_id","price","trigger_price","updateOrder","updateAlgoOrder","_cancelOrder","source","version","then","res","success","mutate","Error","message","cancelOrder","cancelAlgoOrder","loadMore","setSize","cancelTPSLChildOrder","rootAlgoOrderId","is_activated","updateTPSLOrder","childOrders","isLoading","refresh","errors","submitting","updateAlglOrder"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/orderly/{usePositionStream.d.ts → usePositionStream/usePositionStream.d.ts}

@@ -10,7 +10,7 @@ export interface PositionReturn {
 export declare const usePositionStream: (symbol?: string, options?: SWRConfiguration & {
     calcMode?: PriceMode;
 }) => readonly [{
-    readonly rows: API.PositionExt[] | null;
+    readonly rows: API.PositionTPSLExt[] | null;
     readonly aggregated: any;
     readonly totalCollateral: Decimal;
     readonly totalValue: Decimal;

package/lib/orderly/usePositionStream/usePositionStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePositionStream.d.ts","sourceRoot":"","sources":["../../../src/orderly/usePositionStream/usePositionStream.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,KAAK,CAAC;AAG5C,OAAO,EACL,KAAK,GAAG,EACR,WAAW,EAIZ,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EAAE,OAAO,EAAQ,MAAM,wBAAwB,CAAC;AASvD,KAAK,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;AAE3C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,CACL,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,GAAG,MAAM,CAAC,KAC5D,IAAI,CAAC;CACX;AAED,eAAO,MAAM,iBAAiB,YAInB,MAAM,YACL,gBAAgB,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;EAiStD,CAAC;AAEF,eAAO,MAAM,yBAAyB,sBAIpC,CAAC"}

package/lib/orderly/{usePositionStream.js → usePositionStream/usePositionStream.js}

@@ -17,16 +17,19 @@ _export(exports, {
     }
 });
 const _react = require("react");
-const _usePrivateQuery = require("../usePrivateQuery");
+const _usePrivateQuery = require("../../usePrivateQuery");
 const _perp = require("@orderly.network/perp");
-const _createGetter = require("../utils/createGetter");
-const _useFundingRates = require("./useFundingRates");
-const _useSymbolsInfo = require("./useSymbolsInfo");
-const _useMarkPricesStream = require("./useMarkPricesStream");
+const _createGetter = require("../../utils/createGetter");
+const _useFundingRates = require("../useFundingRates");
+const _types = require("@orderly.network/types");
+const _useSymbolsInfo = require("../useSymbolsInfo");
+const _useMarkPricesStream = require("../useMarkPricesStream");
 const _ramda = require("ramda");
-const _parseHolding = require("../utils/parseHolding");
+const _parseHolding = require("../../utils/parseHolding");
 const _utils = require("@orderly.network/utils");
-const _useMarketsStream = require("./useMarketsStream");
+const _useMarketsStream = require("../useMarketsStream");
+const _orderlyHooks = require("../orderlyHooks");
+const _utils1 = require("./utils");
 const usePositionStream = (/**
    * If symbol is passed, only the position of that symbol will be returned.
    */ symbol, options)=>{
@@ -49,6 +52,16 @@ const usePositionStream = (/**
         onError: (err)=>{}
     });
     const { data: markPrices } = (0, _useMarkPricesStream.useMarkPricesStream)();
+    // get TP/SL orders;
+    const [tpslOrders] = (0, _orderlyHooks.useOrderStream)({
+        status: _types.OrderStatus.INCOMPLETE,
+        includes: [
+            _types.AlgoOrderRootType.POSITIONAL_TP_SL,
+            _types.AlgoOrderRootType.TP_SL
+        ]
+    });
+    //
+    // console.log("---------------");
     const [priceMode, setPriceMode] = (0, _react.useState)(options?.calcMode || "markPrice");
     (0, _react.useEffect)(()=>{
         if (options?.calcMode && priceMode !== options?.calcMode) {
@@ -58,8 +71,6 @@ const usePositionStream = (/**
         options?.calcMode
     ]);
     const { data: tickers } = (0, _useMarketsStream.useMarketsStream)();
-    // console.log("mark prices", markPrices);
-    // console.log("tickers", tickers);
     const tickerPrices = (0, _react.useMemo)(()=>{
         const data = Object.create(null);
         tickers?.forEach((item)=>{
@@ -190,6 +201,8 @@ const usePositionStream = (/**
         const total = totalCollateral.toNumber();
         let rows = formatedPositions[0].filter((item)=>item.position_qty !== 0).map((item)=>{
             const info = symbolInfo?.[item.symbol];
+            const related_order = Array.isArray(tpslOrders) ? (0, _utils1.findPositionTPSLFromOrders)(tpslOrders, item.symbol) : undefined;
+            const tp_sl_pricer = !!related_order ? (0, _utils1.findTPSLFromOrder)(related_order) : undefined;
             const MMR = _perp.positions.MMR({
                 baseMMR: info("base_mmr"),
                 baseIMR: info("base_imr"),
@@ -204,13 +217,12 @@ const usePositionStream = (/**
                     markPrice: item.mark_price,
                     MMR
                 }),
-                // est_liq_price: positions.liqPrice({
-                //   markPrice: item.mark_price,
-                //   totalCollateral: total,
-                //   positionQty: item.position_qty,
-                //   MMR,
-                // }),
-                mmr: MMR
+                tp_trigger_price: tp_sl_pricer?.tp_trigger_price,
+                sl_trigger_price: tp_sl_pricer?.sl_trigger_price,
+                mmr: MMR,
+                // has_position_tp_sl:
+                //   !tp_sl_pricer?.sl_trigger_price && !tp_sl_pricer?.tp_trigger_price,
+                algo_order: related_order
             };
         });
         // calculate est_liq_price
@@ -232,13 +244,9 @@ const usePositionStream = (/**
         formatedPositions,
         symbolInfo,
         accountInfo,
-        totalCollateral
+        totalCollateral,
+        tpslOrders
     ]);
-    // useEffect(() => {
-    //   ee.on("positions:changed", () => {
-    //     updatePositions();
-    //   });
-    // }, []);
     const positionInfoGetter = (0, _createGetter.createGetter)(data, 1);
     return [
         {

package/lib/orderly/usePositionStream/usePositionStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/orderly/usePositionStream/usePositionStream.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from \"react\";\nimport { usePrivateQuery } from \"../../usePrivateQuery\";\nimport { account, positions } from \"@orderly.network/perp\";\nimport { type SWRConfiguration } from \"swr\";\nimport { createGetter } from \"../../utils/createGetter\";\nimport { useFundingRates } from \"../useFundingRates\";\nimport {\n  type API,\n  OrderEntity,\n  AlgoOrderType,\n  AlgoOrderRootType,\n  OrderStatus,\n} from \"@orderly.network/types\";\nimport { useSymbolsInfo } from \"../useSymbolsInfo\";\nimport { useMarkPricesStream } from \"../useMarkPricesStream\";\nimport { pathOr, propOr } from \"ramda\";\nimport { parseHolding } from \"../../utils/parseHolding\";\nimport { Decimal, zero } from \"@orderly.network/utils\";\nimport { useMarketsStream } from \"../useMarketsStream\";\nimport { useOrderStream } from \"../orderlyHooks\";\nimport {\n  findPositionTPSLFromOrders,\n  findTPSLFromOrder,\n  findTPSLFromOrders,\n} from \"./utils\";\n\ntype PriceMode = \"markPrice\" | \"lastPrice\";\n\nexport interface PositionReturn {\n  data: any[];\n  loading: boolean;\n  close: (\n    order: Pick<OrderEntity, \"order_type\" | \"order_price\" | \"side\">\n  ) => void;\n}\n\nexport const usePositionStream = (\n  /**\n   * If symbol is passed, only the position of that symbol will be returned.\n   */\n  symbol?: string,\n  options?: SWRConfiguration & { calcMode?: PriceMode }\n) => {\n  const symbolInfo = useSymbolsInfo();\n  const { data: accountInfo } =\n    usePrivateQuery<API.AccountInfo>(\"/v1/client/info\");\n\n  const { data: holding } = usePrivateQuery<API.Holding[]>(\n    \"/v1/client/holding\",\n    {\n      formatter: (data) => {\n        return data.holding;\n      },\n    }\n  );\n\n  const fundingRates = useFundingRates();\n\n  const {\n    data,\n    error,\n    mutate: refreshPositions,\n  } = usePrivateQuery<API.PositionInfo>(`/v1/positions`, {\n    // revalidateOnFocus: false,\n    // revalidateOnReconnect: false,\n    // dedupingInterval: 200,\n    // keepPreviousData: false,\n    // revalidateIfStale: true,\n    ...options,\n\n    formatter: (data) => data,\n    onError: (err) => {},\n  });\n\n  const { data: markPrices } = useMarkPricesStream();\n\n  // get TP/SL orders;\n\n  const [tpslOrders] = useOrderStream({\n    status: OrderStatus.INCOMPLETE,\n    includes: [AlgoOrderRootType.POSITIONAL_TP_SL, AlgoOrderRootType.TP_SL],\n  });\n  //\n\n  // console.log(\"---------------\");\n\n  const [priceMode, setPriceMode] = useState(options?.calcMode || \"markPrice\");\n\n  useEffect(() => {\n    if (options?.calcMode && priceMode !== options?.calcMode) {\n      setPriceMode(options?.calcMode);\n    }\n  }, [options?.calcMode]);\n\n  const { data: tickers } = useMarketsStream();\n\n  const tickerPrices = useMemo(() => {\n    const data: Record<string, number> = Object.create(null);\n    tickers?.forEach((item) => {\n      // @ts-ignore\n      data[item.symbol] = item[\"24h_close\"];\n    });\n    return data;\n  }, [tickers]);\n\n  const formatedPositions = useMemo<[API.PositionExt[], any] | null>(() => {\n    if (!data?.rows || symbolInfo.isNil || !accountInfo) return null;\n\n    const filteredData =\n      typeof symbol === \"undefined\" || symbol === \"\"\n        ? data.rows\n        : data.rows.filter((item) => {\n            return item.symbol === symbol;\n          });\n\n    let unrealPnL_total = zero,\n      notional_total = zero,\n      unsettlementPnL_total = zero;\n\n    const formatted = filteredData.map((item: API.Position) => {\n      // const price = (markPrices as any)[item.symbol] ?? item.mark_price;\n      const unRealizedPrice = propOr(\n        item.mark_price,\n        item.symbol,\n        priceMode === \"markPrice\" ? markPrices : tickerPrices\n      ) as unknown as number;\n\n      const price = propOr(\n        item.mark_price,\n        item.symbol,\n        markPrices\n      ) as unknown as number;\n\n      const info = symbolInfo[item.symbol];\n      //\n\n      const notional = positions.notional(item.position_qty, price);\n\n      const unrealPnl = positions.unrealizedPnL({\n        qty: item.position_qty,\n        openPrice: item?.average_open_price,\n        markPrice: unRealizedPrice,\n      });\n\n      const imr = account.IMR({\n        maxLeverage: accountInfo.max_leverage,\n        baseIMR: info(\"base_imr\"),\n        IMR_Factor: accountInfo.imr_factor[item.symbol] as number,\n        positionNotional: notional,\n        ordersNotional: 0,\n        IMR_factor_power: 4 / 5,\n      });\n\n      const unrealPnlROI = positions.unrealizedPnLROI({\n        positionQty: item.position_qty,\n        openPrice: item.average_open_price,\n        IMR: imr,\n        unrealizedPnL: unrealPnl,\n      });\n\n      const unsettlementPnL = positions.unsettlementPnL({\n        positionQty: item.position_qty,\n        markPrice: price,\n        costPosition: item.cost_position,\n        sumUnitaryFunding: fundingRates[item.symbol]?.(\n          \"sum_unitary_funding\",\n          0\n        ),\n        lastSumUnitaryFunding: item.last_sum_unitary_funding,\n      });\n\n      unrealPnL_total = unrealPnL_total.add(unrealPnl);\n      notional_total = notional_total.add(notional);\n      unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL);\n\n      return {\n        ...item,\n        mark_price: price,\n        mm: 0,\n        notional,\n        unsettlement_pnl: unsettlementPnL,\n        unrealized_pnl: unrealPnl,\n        unrealized_pnl_ROI: unrealPnlROI,\n      };\n    });\n\n    return [\n      formatted,\n      {\n        unrealPnL: unrealPnL_total.toNumber(),\n        notional: notional_total.toNumber(),\n        unsettledPnL: unsettlementPnL_total.toNumber(),\n      },\n    ];\n  }, [\n    data?.rows,\n    symbolInfo,\n    accountInfo,\n    markPrices,\n    priceMode,\n    tickerPrices,\n    symbol,\n    holding,\n  ]);\n\n  // const showSymbol = useCallback((symbol: string) => {\n  //   setVisibleSymbol(symbol);\n  // }, []);\n\n  const [totalCollateral, totalValue, totalUnrealizedROI] = useMemo<\n    [Decimal, Decimal, number]\n  >(() => {\n    if (!holding || !markPrices) {\n      return [zero, zero, 0];\n    }\n    const unsettlemnedPnL = pathOr(0, [1, \"unsettledPnL\"])(formatedPositions);\n    const unrealizedPnL = pathOr(0, [1, \"unrealPnL\"])(formatedPositions);\n\n    const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);\n\n    const totalCollateral = account.totalCollateral({\n      USDCHolding: USDC_holding,\n      nonUSDCHolding: nonUSDC,\n      unsettlementPnL: unsettlemnedPnL,\n    });\n\n    const totalValue = account.totalValue({\n      totalUnsettlementPnL: unsettlemnedPnL,\n      USDCHolding: USDC_holding,\n      nonUSDCHolding: nonUSDC,\n    });\n\n    const totalUnrealizedROI = account.totalUnrealizedROI({\n      totalUnrealizedPnL: unrealizedPnL,\n      totalValue: totalValue.toNumber(),\n    });\n\n    return [totalCollateral, totalValue, totalUnrealizedROI];\n  }, [holding, formatedPositions, markPrices]);\n\n  const positionsRows = useMemo<API.PositionTPSLExt[] | null>(() => {\n    if (!formatedPositions) return null;\n\n    if (!symbolInfo || !accountInfo) return formatedPositions[0];\n\n    const total = totalCollateral.toNumber();\n\n    let rows = formatedPositions[0]\n      .filter((item) => item.position_qty !== 0)\n      .map((item) => {\n        const info = symbolInfo?.[item.symbol];\n\n        const related_order = Array.isArray(tpslOrders)\n          ? findPositionTPSLFromOrders(tpslOrders, item.symbol)\n          : undefined;\n\n        const tp_sl_pricer = !!related_order\n          ? findTPSLFromOrder(related_order)\n          : undefined;\n\n        const MMR = positions.MMR({\n          baseMMR: info(\"base_mmr\"),\n          baseIMR: info(\"base_imr\"),\n          IMRFactor: accountInfo.imr_factor[item.symbol] as number,\n          positionNotional: item.notional,\n          IMR_factor_power: 4 / 5,\n        });\n\n        return {\n          ...item,\n          mm: positions.maintenanceMargin({\n            positionQty: item.position_qty,\n            markPrice: item.mark_price,\n            MMR,\n          }),\n          tp_trigger_price: tp_sl_pricer?.tp_trigger_price,\n          sl_trigger_price: tp_sl_pricer?.sl_trigger_price,\n\n          mmr: MMR,\n\n          // has_position_tp_sl:\n          //   !tp_sl_pricer?.sl_trigger_price && !tp_sl_pricer?.tp_trigger_price,\n          algo_order: related_order,\n        };\n      });\n\n    // calculate est_liq_price\n    rows = rows.map((item) => {\n      const est_liq_price = positions.liqPrice({\n        markPrice: item.mark_price,\n        totalCollateral: total,\n        positionQty: item.position_qty,\n        positions: rows,\n        MMR: item.mmr,\n      });\n      return {\n        ...item,\n        est_liq_price,\n      };\n    });\n\n    return rows;\n  }, [formatedPositions, symbolInfo, accountInfo, totalCollateral, tpslOrders]);\n\n  const positionInfoGetter = createGetter<\n    Omit<API.PositionInfo, \"rows\">,\n    keyof Omit<API.PositionInfo, \"rows\">\n  >(data as any, 1);\n\n  return [\n    {\n      rows: positionsRows,\n      aggregated: {\n        ...(formatedPositions?.[1] ?? {}),\n        unrealPnlROI: totalUnrealizedROI,\n      },\n      totalCollateral,\n      totalValue,\n      totalUnrealizedROI,\n    },\n    positionInfoGetter,\n    {\n      // close: onClosePosition,\n      loading: false,\n      // showSymbol,\n      error,\n      // loadMore: () => {},\n      refresh: refreshPositions,\n    },\n  ] as const;\n};\n\nexport const pathOr_unsettledPnLPathOr = pathOr(0, [\n  0,\n  \"aggregated\",\n  \"unsettledPnL\",\n]);\n"],"names":["pathOr_unsettledPnLPathOr","usePositionStream","symbol","options","symbolInfo","useSymbolsInfo","data","accountInfo","usePrivateQuery","holding","formatter","fundingRates","useFundingRates","error","mutate","refreshPositions","onError","err","markPrices","useMarkPricesStream","tpslOrders","useOrderStream","status","OrderStatus","INCOMPLETE","includes","AlgoOrderRootType","POSITIONAL_TP_SL","TP_SL","priceMode","setPriceMode","useState","calcMode","useEffect","tickers","useMarketsStream","tickerPrices","useMemo","Object","create","forEach","item","formatedPositions","rows","isNil","filteredData","filter","unrealPnL_total","zero","notional_total","unsettlementPnL_total","formatted","map","unRealizedPrice","propOr","mark_price","price","info","notional","positions","position_qty","unrealPnl","unrealizedPnL","qty","openPrice","average_open_price","markPrice","imr","account","IMR","maxLeverage","max_leverage","baseIMR","IMR_Factor","imr_factor","positionNotional","ordersNotional","IMR_factor_power","unrealPnlROI","unrealizedPnLROI","positionQty","unsettlementPnL","costPosition","cost_position","sumUnitaryFunding","lastSumUnitaryFunding","last_sum_unitary_funding","add","mm","unsettlement_pnl","unrealized_pnl","unrealized_pnl_ROI","unrealPnL","toNumber","unsettledPnL","totalCollateral","totalValue","totalUnrealizedROI","unsettlemnedPnL","pathOr","USDC_holding","nonUSDC","parseHolding","USDCHolding","nonUSDCHolding","totalUnsettlementPnL","totalUnrealizedPnL","positionsRows","total","related_order","Array","isArray","findPositionTPSLFromOrders","undefined","tp_sl_pricer","findTPSLFromOrder","MMR","baseMMR","IMRFactor","maintenanceMargin","tp_trigger_price","sl_trigger_price","mmr","algo_order","est_liq_price","liqPrice","positionInfoGetter","createGetter","aggregated","loading","refresh"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/orderly/usePositionStream/utils.d.ts

@@ -0,0 +1,8 @@
+import { API, AlgoOrderEntity } from "@orderly.network/types";
+export declare const findTPSLFromOrders: (orders: API.AlgoOrder[], symbol: string) => Partial<AlgoOrderEntity> | undefined;
+export declare const findTPSLFromOrder: (order: API.AlgoOrder) => {
+    tp_trigger_price?: number | undefined;
+    sl_trigger_price?: number | undefined;
+};
+export declare const findPositionTPSLFromOrders: (orders: API.AlgoOrder[], symbol: string) => API.AlgoOrder | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/lib/orderly/usePositionStream/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/orderly/usePositionStream/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,eAAe,EAIhB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,kBAAkB,WACrB,IAAI,SAAS,EAAE,UACf,MAAM,KACb,QAAQ,eAAe,CAAC,GAAG,SAO7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,UACrB,IAAI,SAAS;;;CA6BrB,CAAC;AAEF,eAAO,MAAM,0BAA0B,WAC7B,IAAI,SAAS,EAAE,UACf,MAAM,KACb,IAAI,SAAS,GAAG,SAalB,CAAC"}

package/lib/orderly/usePositionStream/utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    findPositionTPSLFromOrders: function() {
+        return findPositionTPSLFromOrders;
+    },
+    findTPSLFromOrder: function() {
+        return findTPSLFromOrder;
+    },
+    findTPSLFromOrders: function() {
+        return findTPSLFromOrders;
+    }
+});
+const _types = require("@orderly.network/types");
+const findTPSLFromOrders = (orders, symbol)=>{
+    const order = findPositionTPSLFromOrders(orders, symbol);
+    // console.log("!!!!!", order);
+    if (!order) return;
+    return findTPSLFromOrder(order);
+};
+const findTPSLFromOrder = (order)=>{
+    let tp_trigger_price;
+    let sl_trigger_price;
+    const tpOrder = order.child_orders.find((order)=>order.algo_type === _types.AlgoOrderType.TAKE_PROFIT);
+    const slOrder = order.child_orders.find((order)=>order.algo_type === _types.AlgoOrderType.STOP_LOSS);
+    if (tpOrder) {
+        tp_trigger_price = tpOrder.trigger_price;
+    // take_profit_qty =  tpOrder.quantity ;
+    }
+    if (slOrder) {
+        sl_trigger_price = slOrder.trigger_price;
+    // stop_loss_qty = slOrder.quantity;
+    }
+    return {
+        tp_trigger_price,
+        sl_trigger_price
+    };
+};
+const findPositionTPSLFromOrders = (orders, symbol)=>{
+    return orders?.find((order)=>{
+        // console.log(order.symbol, symbol, order.algo_type);
+        return order.symbol === symbol && order.algo_type === _types.AlgoOrderRootType.POSITIONAL_TP_SL && (order.root_algo_status === _types.OrderStatus.NEW || order.root_algo_status === _types.OrderStatus.REPLACED || order.root_algo_status === _types.OrderStatus.PARTIAL_FILLED);
+    });
+// return order;
+};
+
+//# sourceMappingURL=utils.js.map

package/lib/orderly/usePositionStream/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/orderly/usePositionStream/utils.ts"],"sourcesContent":["import {\n  API,\n  AlgoOrderEntity,\n  AlgoOrderType,\n  AlgoOrderRootType,\n  OrderStatus,\n} from \"@orderly.network/types\";\n\nexport const findTPSLFromOrders = (\n  orders: API.AlgoOrder[],\n  symbol: string\n): Partial<AlgoOrderEntity> | undefined => {\n  const order = findPositionTPSLFromOrders(orders, symbol);\n\n  // console.log(\"!!!!!\", order);\n\n  if (!order) return;\n  return findTPSLFromOrder(order);\n};\n\nexport const findTPSLFromOrder = (\n  order: API.AlgoOrder\n): {\n  tp_trigger_price?: number;\n  sl_trigger_price?: number;\n} => {\n  let tp_trigger_price;\n\n  let sl_trigger_price;\n\n  const tpOrder = order.child_orders.find(\n    (order: any) => order.algo_type === AlgoOrderType.TAKE_PROFIT\n  );\n  const slOrder = order.child_orders.find(\n    (order: any) => order.algo_type === AlgoOrderType.STOP_LOSS\n  );\n\n  if (tpOrder) {\n    tp_trigger_price = tpOrder.trigger_price;\n    // take_profit_qty =  tpOrder.quantity ;\n  }\n  if (slOrder) {\n    sl_trigger_price = slOrder.trigger_price;\n    // stop_loss_qty = slOrder.quantity;\n  }\n\n  return {\n    tp_trigger_price,\n    sl_trigger_price,\n  };\n};\n\nexport const findPositionTPSLFromOrders = (\n  orders: API.AlgoOrder[],\n  symbol: string\n): API.AlgoOrder | undefined => {\n  return orders?.find((order) => {\n    // console.log(order.symbol, symbol, order.algo_type);\n    return (\n      order.symbol === symbol &&\n      order.algo_type === AlgoOrderRootType.POSITIONAL_TP_SL &&\n      (order.root_algo_status === OrderStatus.NEW ||\n        order.root_algo_status === OrderStatus.REPLACED ||\n        order.root_algo_status === OrderStatus.PARTIAL_FILLED)\n    );\n  });\n\n  // return order;\n};\n"],"names":["findPositionTPSLFromOrders","findTPSLFromOrder","findTPSLFromOrders","orders","symbol","order","tp_trigger_price","sl_trigger_price","tpOrder","child_orders","find","algo_type","AlgoOrderType","TAKE_PROFIT","slOrder","STOP_LOSS","trigger_price","AlgoOrderRootType","POSITIONAL_TP_SL","root_algo_status","OrderStatus","NEW","REPLACED","PARTIAL_FILLED"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAoDaA,0BAA0B;eAA1BA;;IAhCAC,iBAAiB;eAAjBA;;IAZAC,kBAAkB;eAAlBA;;;uBAFN;AAEA,MAAMA,qBAAqB,CAChCC,QACAC;IAEA,MAAMC,QAAQL,2BAA2BG,QAAQC;IAEjD,+BAA+B;IAE/B,IAAI,CAACC,OAAO;IACZ,OAAOJ,kBAAkBI;AAC3B;AAEO,MAAMJ,oBAAoB,CAC/BI;IAKA,IAAIC;IAEJ,IAAIC;IAEJ,MAAMC,UAAUH,MAAMI,YAAY,CAACC,IAAI,CACrC,CAACL,QAAeA,MAAMM,SAAS,KAAKC,oBAAa,CAACC,WAAW;IAE/D,MAAMC,UAAUT,MAAMI,YAAY,CAACC,IAAI,CACrC,CAACL,QAAeA,MAAMM,SAAS,KAAKC,oBAAa,CAACG,SAAS;IAG7D,IAAIP,SAAS;QACXF,mBAAmBE,QAAQQ,aAAa;IACxC,wCAAwC;IAC1C;IACA,IAAIF,SAAS;QACXP,mBAAmBO,QAAQE,aAAa;IACxC,oCAAoC;IACtC;IAEA,OAAO;QACLV;QACAC;IACF;AACF;AAEO,MAAMP,6BAA6B,CACxCG,QACAC;IAEA,OAAOD,QAAQO,KAAK,CAACL;QACnB,sDAAsD;QACtD,OACEA,MAAMD,MAAM,KAAKA,UACjBC,MAAMM,SAAS,KAAKM,wBAAiB,CAACC,gBAAgB,IACrDb,CAAAA,MAAMc,gBAAgB,KAAKC,kBAAW,CAACC,GAAG,IACzChB,MAAMc,gBAAgB,KAAKC,kBAAW,CAACE,QAAQ,IAC/CjB,MAAMc,gBAAgB,KAAKC,kBAAW,CAACG,cAAc,AAAD;IAE1D;AAEA,gBAAgB;AAClB"}

package/lib/orderly/usePrivateDataObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrivateDataObserver.d.ts","sourceRoot":"","sources":["../../src/orderly/usePrivateDataObserver.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,eAAO,MAAM,sBAAsB;uBAEd,MAAM,KAAK,IAAI,MAAM,EAAE,cAAc,CAAC;UA4K1D,CAAC"}
+{"version":3,"file":"usePrivateDataObserver.d.ts","sourceRoot":"","sources":["../../src/orderly/usePrivateDataObserver.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAMjD,eAAO,MAAM,sBAAsB;uBAEd,MAAM,KAAK,IAAI,MAAM,EAAE,cAAc,CAAC;UAgK1D,CAAC"}