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

package/lib/services/orderCreator/stopMarketOrderCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/orderCreator/stopMarketOrderCreator.ts"],"sourcesContent":["import {\n  AlgoOrderEntity,\n  AlgoOrderRootType,\n  OrderEntity,\n  OrderType,\n  TriggerPriceType,\n} from \"@orderly.network/types\";\nimport { OrderFormEntity, ValuesDepConfig, VerifyResult } from \"./interface\";\n\nimport { pick } from \"ramda\";\nimport { BaseOrderCreator } from \"./baseCreator\";\n\nexport class StopMarketOrderCreator extends BaseOrderCreator<AlgoOrderEntity> {\n  create(\n    values: AlgoOrderEntity & {\n      order_quantity: number;\n      order_price: number;\n    }\n  ) {\n    const order = {\n      ...this.baseOrder(values as unknown as OrderEntity),\n      // order_price: values.order_price,\n      trigger_price: values.trigger_price!,\n      algo_type: AlgoOrderRootType.STOP,\n      type: OrderType.MARKET,\n      quantity: values[\"order_quantity\"]!,\n      // price: values[\"order_price\"],\n      trigger_price_type: TriggerPriceType.MARK_PRICE,\n    };\n\n    return pick(\n      [\n        \"symbol\",\n        \"trigger_price\",\n        \"algo_type\",\n        \"type\",\n        \"quantity\",\n        // \"price\",\n        \"trigger_price_type\",\n        \"side\",\n        \"reduce_only\",\n        \"visible_quantity\",\n      ],\n      order\n    );\n\n    // return order;\n  }\n  validate(\n    values: OrderFormEntity,\n    config: ValuesDepConfig\n  ): Promise<VerifyResult> {\n    return this.baseValidate(values, config).then((errors) => {\n      // const errors = this.baseValidate(values, config);\n      // @ts-ignore\n      const { order_price, trigger_price, side } = values;\n\n      if (!trigger_price) {\n        errors.trigger_price = {\n          type: \"required\",\n          message: \"Trigger price is required\",\n        };\n      }\n\n      return errors;\n    });\n  }\n}\n"],"names":["StopMarketOrderCreator","BaseOrderCreator","create","values","order","baseOrder","trigger_price","algo_type","AlgoOrderRootType","STOP","type","OrderType","MARKET","quantity","trigger_price_type","TriggerPriceType","MARK_PRICE","pick","validate","config","baseValidate","then","errors","order_price","side","message"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;uBANN;uBAGc;6BACY;AAE1B,MAAMA,+BAA+BC,6BAAgB;IAC1DC,OACEC,MAGC,EACD;QACA,MAAMC,QAAQ;YACZ,GAAG,IAAI,CAACC,SAAS,CAACF,OAAiC;YACnD,mCAAmC;YACnCG,eAAeH,OAAOG,aAAa;YACnCC,WAAWC,wBAAiB,CAACC,IAAI;YACjCC,MAAMC,gBAAS,CAACC,MAAM;YACtBC,UAAUV,MAAM,CAAC,iBAAiB;YAClC,gCAAgC;YAChCW,oBAAoBC,uBAAgB,CAACC,UAAU;QACjD;QAEA,OAAOC,IAAAA,WAAI,EACT;YACE;YACA;YACA;YACA;YACA;YACA,WAAW;YACX;YACA;YACA;YACA;SACD,EACDb;IAGF,gBAAgB;IAClB;IACAc,SACEf,MAAuB,EACvBgB,MAAuB,EACA;QACvB,OAAO,IAAI,CAACC,YAAY,CAACjB,QAAQgB,QAAQE,IAAI,CAAC,CAACC;YAC7C,oDAAoD;YACpD,aAAa;YACb,MAAM,EAAEC,WAAW,EAAEjB,aAAa,EAAEkB,IAAI,EAAE,GAAGrB;YAE7C,IAAI,CAACG,eAAe;gBAClBgB,OAAOhB,aAAa,GAAG;oBACrBI,MAAM;oBACNe,SAAS;gBACX;YACF;YAEA,OAAOH;QACT;IACF;AACF"}

package/lib/services/orderCreator/tpslOrderCreator.d.ts

@@ -0,0 +1,32 @@
+import { AlgoOrderEntity, OrderType, API } from "@orderly.network/types";
+import { TriggerPriceType } from "@orderly.network/types";
+import { AlgoOrderType } from "@orderly.network/types";
+import { AlgoOrderRootType } from "@orderly.network/types";
+import { OrderSide } from "@orderly.network/types";
+import { AlgoOrderUpdateEntity, BaseAlgoOrderCreator } from "./baseAlgoCreator";
+import { ValuesDepConfig } from "./interface";
+export declare class TPSLOrderCreator extends BaseAlgoOrderCreator<AlgoOrderEntity<AlgoOrderRootType.TP_SL>> {
+    create(values: AlgoOrderEntity<AlgoOrderRootType.TP_SL>, config: ValuesDepConfig): {
+        algo_type: AlgoOrderRootType;
+        trigger_price_type: TriggerPriceType;
+        reduce_only: boolean;
+        quantity: string | number;
+        symbol: string;
+        child_orders: {
+            algo_type: AlgoOrderType;
+            reduce_only: boolean;
+            side: OrderSide;
+            type: OrderType;
+            trigger_price: string | number;
+            symbol: string;
+            is_activated: boolean;
+        }[];
+    };
+    crateUpdateOrder(values: AlgoOrderEntity<AlgoOrderRootType.TP_SL>, oldValue: API.AlgoOrder, config: ValuesDepConfig): [
+        {
+            child_orders: AlgoOrderUpdateEntity[];
+        },
+        AlgoOrderEntity<AlgoOrderRootType.TP_SL>
+    ];
+}
+//# sourceMappingURL=tpslOrderCreator.d.ts.map

package/lib/services/orderCreator/tpslOrderCreator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tpslOrderCreator.d.ts","sourceRoot":"","sources":["../../../src/services/orderCreator/tpslOrderCreator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C,qBAAa,gBAAiB,SAAQ,oBAAoB,CACxD,eAAe,CAAC,iBAAiB,CAAC,KAAK,CAAC,CACzC;IACC,MAAM,CACJ,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAChD,MAAM,EAAE,eAAe;;;;;;;;;;;;;;;;IAoDzB,gBAAgB,CACd,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAChD,QAAQ,EAAE,GAAG,CAAC,SAAS,EACvB,MAAM,EAAE,eAAe,GACtB;QACD;YAAE,YAAY,EAAE,qBAAqB,EAAE,CAAA;SAAE;QACzC,eAAe,CAAC,iBAAiB,CAAC,KAAK,CAAC;KACzC;CAsDF"}

package/lib/services/orderCreator/tpslOrderCreator.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TPSLOrderCreator", {
+    enumerable: true,
+    get: function() {
+        return TPSLOrderCreator;
+    }
+});
+const _types = require("@orderly.network/types");
+const _baseAlgoCreator = require("./baseAlgoCreator");
+const _utils = require("@orderly.network/utils");
+class TPSLOrderCreator extends _baseAlgoCreator.BaseAlgoOrderCreator {
+    create(values, config) {
+        const side = values.side === _types.OrderSide.BUY ? _types.OrderSide.SELL : _types.OrderSide.BUY;
+        const child_orders = [];
+        if (typeof values.tp_trigger_price !== "undefined") {
+            const tp_trigger_price = !!values.sl_trigger_price ? new _utils.Decimal(values.tp_trigger_price).todp(config.symbol.quote_dp).toNumber() : values.tp_trigger_price;
+            child_orders.push({
+                algo_type: _types.AlgoOrderType.TAKE_PROFIT,
+                reduce_only: true,
+                side,
+                type: _types.OrderType.MARKET,
+                trigger_price: tp_trigger_price,
+                symbol: values.symbol,
+                is_activated: !!values.tp_trigger_price
+            });
+        }
+        if (typeof values.sl_trigger_price !== "undefined") {
+            const sl_trigger_price = !!values.sl_trigger_price ? new _utils.Decimal(values.sl_trigger_price).todp(config.symbol.quote_dp).toNumber() : values.sl_trigger_price;
+            child_orders.push({
+                algo_type: _types.AlgoOrderType.STOP_LOSS,
+                reduce_only: true,
+                side,
+                type: _types.OrderType.MARKET,
+                trigger_price: sl_trigger_price,
+                symbol: values.symbol,
+                is_activated: !!values.sl_trigger_price
+            });
+        }
+        return {
+            algo_type: _types.AlgoOrderRootType.TP_SL,
+            trigger_price_type: _types.TriggerPriceType.MARK_PRICE,
+            reduce_only: true,
+            quantity: values.quantity,
+            symbol: values.symbol,
+            child_orders
+        };
+    }
+    crateUpdateOrder(values, oldValue, config) {
+        const data = this.create(values, config);
+        const newData = [];
+        const needUpdateQty = values.quantity !== oldValue.quantity;
+        data.child_orders.forEach((order)=>{
+            // find the old order
+            let _order = Object.create(null);
+            if (needUpdateQty) {
+                _order["quantity"] = data.quantity;
+            }
+            const oldOrder = oldValue.child_orders?.find((oldOrder)=>oldOrder.algo_type === order.algo_type);
+            if (oldOrder) {
+                if (!order.is_activated) {
+                    _order["is_activated"] = false;
+                } else if (oldOrder.trigger_price !== order.trigger_price) {
+                    // _order["order_id"] = Number(oldOrder.algo_order_id);
+                    _order["trigger_price"] = order.trigger_price;
+                }
+                if (Object.keys(_order).length > 0) {
+                    _order["order_id"] = Number(oldOrder.algo_order_id);
+                    newData.push(_order);
+                }
+            }
+        });
+        if (needUpdateQty && newData.length < 2) {
+            // if quantity is changed, need to update all child orders
+            const missingOrders = oldValue.child_orders.filter((order)=>order.algo_order_id !== newData[0].order_id);
+            if (missingOrders.length) {
+                newData.push({
+                    quantity: Number(data.quantity),
+                    order_id: missingOrders[0].algo_order_id
+                });
+            }
+        }
+        return [
+            {
+                child_orders: newData
+            },
+            data
+        ];
+    }
+}
+
+//# sourceMappingURL=tpslOrderCreator.js.map

package/lib/services/orderCreator/tpslOrderCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/orderCreator/tpslOrderCreator.ts"],"sourcesContent":["import { AlgoOrderEntity, OrderType, API } from \"@orderly.network/types\";\nimport { TriggerPriceType } from \"@orderly.network/types\";\nimport { AlgoOrderType } from \"@orderly.network/types\";\nimport { AlgoOrderRootType } from \"@orderly.network/types\";\nimport { OrderSide } from \"@orderly.network/types\";\nimport { AlgoOrderUpdateEntity, BaseAlgoOrderCreator } from \"./baseAlgoCreator\";\nimport { ValuesDepConfig } from \"./interface\";\nimport { Decimal } from \"@orderly.network/utils\";\n\nexport class TPSLOrderCreator extends BaseAlgoOrderCreator<\n  AlgoOrderEntity<AlgoOrderRootType.TP_SL>\n> {\n  create(\n    values: AlgoOrderEntity<AlgoOrderRootType.TP_SL>,\n    config: ValuesDepConfig\n  ) {\n    const side =\n      values.side! === OrderSide.BUY ? OrderSide.SELL : OrderSide.BUY;\n\n    const child_orders = [];\n\n    if (typeof values.tp_trigger_price !== \"undefined\") {\n      const tp_trigger_price = !!values.sl_trigger_price\n        ? new Decimal(values.tp_trigger_price)\n            .todp(config.symbol.quote_dp)\n            .toNumber()\n        : values.tp_trigger_price;\n\n      child_orders.push({\n        algo_type: AlgoOrderType.TAKE_PROFIT,\n        reduce_only: true,\n        side,\n        type: OrderType.MARKET,\n        trigger_price: tp_trigger_price,\n        symbol: values.symbol,\n        is_activated: !!values.tp_trigger_price,\n      });\n    }\n\n    if (typeof values.sl_trigger_price !== \"undefined\") {\n      const sl_trigger_price = !!values.sl_trigger_price\n        ? new Decimal(values.sl_trigger_price)\n            .todp(config.symbol.quote_dp)\n            .toNumber()\n        : values.sl_trigger_price;\n      child_orders.push({\n        algo_type: AlgoOrderType.STOP_LOSS,\n        reduce_only: true,\n        side,\n        type: OrderType.MARKET,\n        trigger_price: sl_trigger_price,\n        symbol: values.symbol,\n        is_activated: !!values.sl_trigger_price,\n      });\n    }\n\n    return {\n      algo_type: AlgoOrderRootType.TP_SL,\n      trigger_price_type: TriggerPriceType.MARK_PRICE,\n      reduce_only: true,\n      quantity: values.quantity,\n      symbol: values.symbol,\n      child_orders,\n    };\n  }\n\n  crateUpdateOrder(\n    values: AlgoOrderEntity<AlgoOrderRootType.TP_SL>,\n    oldValue: API.AlgoOrder,\n    config: ValuesDepConfig\n  ): [\n    { child_orders: AlgoOrderUpdateEntity[] },\n    AlgoOrderEntity<AlgoOrderRootType.TP_SL>\n  ] {\n    const data = this.create(values, config);\n    const newData: AlgoOrderUpdateEntity[] = [];\n\n    const needUpdateQty = values.quantity !== oldValue.quantity;\n\n    data.child_orders.forEach((order) => {\n      // find the old order\n      let _order = Object.create(null);\n\n      if (needUpdateQty) {\n        _order[\"quantity\"] = data.quantity;\n      }\n\n      const oldOrder = oldValue.child_orders?.find(\n        (oldOrder) => oldOrder.algo_type === order.algo_type\n      );\n\n      if (oldOrder) {\n        if (!order.is_activated) {\n          _order[\"is_activated\"] = false;\n        } else if (oldOrder.trigger_price !== order.trigger_price) {\n          // _order[\"order_id\"] = Number(oldOrder.algo_order_id);\n          _order[\"trigger_price\"] = order.trigger_price as number;\n        }\n\n        if (Object.keys(_order).length > 0) {\n          _order[\"order_id\"] = Number(oldOrder.algo_order_id);\n          newData.push(_order);\n        }\n      }\n    });\n\n    if (needUpdateQty && newData.length < 2) {\n      // if quantity is changed, need to update all child orders\n      const missingOrders = oldValue.child_orders.filter(\n        (order) => order.algo_order_id !== newData[0].order_id\n      );\n\n      if (missingOrders.length) {\n        newData.push({\n          quantity: Number(data.quantity),\n          order_id: missingOrders[0].algo_order_id,\n        });\n      }\n    }\n\n    return [\n      {\n        child_orders: newData,\n      },\n      data,\n    ];\n  }\n}\n"],"names":["TPSLOrderCreator","BaseAlgoOrderCreator","create","values","config","side","OrderSide","BUY","SELL","child_orders","tp_trigger_price","sl_trigger_price","Decimal","todp","symbol","quote_dp","toNumber","push","algo_type","AlgoOrderType","TAKE_PROFIT","reduce_only","type","OrderType","MARKET","trigger_price","is_activated","STOP_LOSS","AlgoOrderRootType","TP_SL","trigger_price_type","TriggerPriceType","MARK_PRICE","quantity","crateUpdateOrder","oldValue","data","newData","needUpdateQty","forEach","order","_order","Object","oldOrder","find","keys","length","Number","algo_order_id","missingOrders","filter","order_id"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/services/orderCreator/tpslPositionOrderCreator.d.ts

@@ -0,0 +1,33 @@
+import { AlgoOrderEntity, AlgoOrderType, OrderType, TriggerPriceType, AlgoOrderRootType } from "@orderly.network/types";
+import { OrderSide } from "@orderly.network/types";
+import { API } from "@orderly.network/types";
+import { AlgoOrderUpdateEntity, BaseAlgoOrderCreator } from "./baseAlgoCreator";
+import { ValuesDepConfig } from "./interface";
+export declare class TPSLPositionOrderCreator extends BaseAlgoOrderCreator<AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>> {
+    create(values: AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>, config: ValuesDepConfig): {
+        algo_type: AlgoOrderRootType;
+        trigger_price_type: TriggerPriceType;
+        symbol: string;
+        child_orders: {
+            algo_type: AlgoOrderType;
+            reduce_only: boolean;
+            side: OrderSide;
+            type: OrderType;
+            trigger_price: string | number;
+            trigger_price_type: TriggerPriceType;
+            symbol: string;
+            is_activated: boolean;
+        }[];
+    };
+    crateUpdateOrder(values: AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>, 
+    /**
+     * The old value of the order
+     */
+    oldValue: API.AlgoOrder, config: ValuesDepConfig): [
+        {
+            child_orders: AlgoOrderUpdateEntity[];
+        },
+        AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>
+    ];
+}
+//# sourceMappingURL=tpslPositionOrderCreator.d.ts.map

package/lib/services/orderCreator/tpslPositionOrderCreator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tpslPositionOrderCreator.d.ts","sourceRoot":"","sources":["../../../src/services/orderCreator/tpslPositionOrderCreator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,aAAa,EACb,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C,qBAAa,wBAAyB,SAAQ,oBAAoB,CAChE,eAAe,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CACpD;IACC,MAAM,CACJ,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,EAC3D,MAAM,EAAE,eAAe;;;;;;;;;;;;;;;IAqDzB,gBAAgB,CACd,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,gBAAgB,CAAC;IAC3D;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,SAAS,EACvB,MAAM,EAAE,eAAe,GACtB;QACD;YAAE,YAAY,EAAE,qBAAqB,EAAE,CAAA;SAAE;QACzC,eAAe,CAAC,iBAAiB,CAAC,gBAAgB,CAAC;KACpD;CAoCF"}

package/lib/services/orderCreator/tpslPositionOrderCreator.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TPSLPositionOrderCreator", {
+    enumerable: true,
+    get: function() {
+        return TPSLPositionOrderCreator;
+    }
+});
+const _types = require("@orderly.network/types");
+const _baseAlgoCreator = require("./baseAlgoCreator");
+const _utils = require("@orderly.network/utils");
+class TPSLPositionOrderCreator extends _baseAlgoCreator.BaseAlgoOrderCreator {
+    create(values, config) {
+        const side = values.side === _types.OrderSide.BUY ? _types.OrderSide.SELL : _types.OrderSide.BUY;
+        const child_orders = [];
+        if (typeof values.tp_trigger_price !== "undefined") {
+            const tp_trigger_price = !!values.tp_trigger_price ? new _utils.Decimal(values.tp_trigger_price).todp(config.symbol.quote_dp).toNumber() : values.tp_trigger_price;
+            child_orders.push({
+                algo_type: _types.AlgoOrderType.TAKE_PROFIT,
+                reduce_only: true,
+                side,
+                type: _types.OrderType.CLOSE_POSITION,
+                trigger_price: tp_trigger_price,
+                trigger_price_type: _types.TriggerPriceType.MARK_PRICE,
+                symbol: values.symbol,
+                is_activated: !!values.tp_trigger_price
+            });
+        }
+        if (typeof values.sl_trigger_price !== "undefined") {
+            const sl_trigger_price = !!values.sl_trigger_price ? new _utils.Decimal(values.sl_trigger_price).todp(config.symbol.quote_dp).toNumber() : values.sl_trigger_price;
+            child_orders.push({
+                algo_type: _types.AlgoOrderType.STOP_LOSS,
+                reduce_only: true,
+                side,
+                type: _types.OrderType.CLOSE_POSITION,
+                trigger_price: sl_trigger_price,
+                trigger_price_type: _types.TriggerPriceType.MARK_PRICE,
+                symbol: values.symbol,
+                is_activated: !!values.sl_trigger_price
+            });
+        }
+        return {
+            algo_type: _types.AlgoOrderRootType.POSITIONAL_TP_SL,
+            trigger_price_type: _types.TriggerPriceType.MARK_PRICE,
+            // reduce_only: true,
+            symbol: values.symbol,
+            child_orders
+        };
+    }
+    crateUpdateOrder(values, /**
+     * The old value of the order
+     */ oldValue, config) {
+        const data = this.create(values, config);
+        const newData = [];
+        data.child_orders.forEach((order)=>{
+            // find the old order
+            const oldOrder = oldValue.child_orders?.find((oldOrder)=>oldOrder.algo_type === order.algo_type);
+            if (oldOrder) {
+                if (!order.is_activated) {
+                    newData.push({
+                        is_activated: false,
+                        order_id: Number(oldOrder.algo_order_id)
+                    });
+                } else if (oldOrder.trigger_price !== order.trigger_price) {
+                    newData.push({
+                        trigger_price: order.trigger_price,
+                        order_id: Number(oldOrder.algo_order_id)
+                    });
+                }
+            }
+        });
+        return [
+            {
+                child_orders: newData
+            },
+            data
+        ];
+    }
+}
+
+//# sourceMappingURL=tpslPositionOrderCreator.js.map

package/lib/services/orderCreator/tpslPositionOrderCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/orderCreator/tpslPositionOrderCreator.ts"],"sourcesContent":["import {\n  AlgoOrderEntity,\n  AlgoOrderType,\n  OrderType,\n  TriggerPriceType,\n  AlgoOrderRootType,\n} from \"@orderly.network/types\";\nimport { OrderSide } from \"@orderly.network/types\";\nimport { API } from \"@orderly.network/types\";\nimport { AlgoOrderUpdateEntity, BaseAlgoOrderCreator } from \"./baseAlgoCreator\";\nimport { ValuesDepConfig } from \"./interface\";\nimport { Decimal } from \"@orderly.network/utils\";\n\nexport class TPSLPositionOrderCreator extends BaseAlgoOrderCreator<\n  AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>\n> {\n  create(\n    values: AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>,\n    config: ValuesDepConfig\n  ) {\n    const side =\n      values.side! === OrderSide.BUY ? OrderSide.SELL : OrderSide.BUY;\n\n    const child_orders = [];\n\n    if (typeof values.tp_trigger_price !== \"undefined\") {\n      const tp_trigger_price = !!values.tp_trigger_price\n        ? new Decimal(values.tp_trigger_price)\n            .todp(config.symbol.quote_dp)\n            .toNumber()\n        : values.tp_trigger_price;\n\n      child_orders.push({\n        algo_type: AlgoOrderType.TAKE_PROFIT,\n        reduce_only: true,\n        side,\n        type: OrderType.CLOSE_POSITION,\n        trigger_price: tp_trigger_price,\n        trigger_price_type: TriggerPriceType.MARK_PRICE,\n        symbol: values.symbol,\n        is_activated: !!values.tp_trigger_price,\n      });\n    }\n\n    if (typeof values.sl_trigger_price !== \"undefined\") {\n      const sl_trigger_price = !!values.sl_trigger_price\n        ? new Decimal(values.sl_trigger_price)\n            .todp(config.symbol.quote_dp)\n            .toNumber()\n        : values.sl_trigger_price;\n      child_orders.push({\n        algo_type: AlgoOrderType.STOP_LOSS,\n        reduce_only: true,\n        side,\n        type: OrderType.CLOSE_POSITION,\n        trigger_price: sl_trigger_price,\n        trigger_price_type: TriggerPriceType.MARK_PRICE,\n        symbol: values.symbol,\n        is_activated: !!values.sl_trigger_price,\n      });\n    }\n\n    return {\n      algo_type: AlgoOrderRootType.POSITIONAL_TP_SL,\n      trigger_price_type: TriggerPriceType.MARK_PRICE,\n      // reduce_only: true,\n      symbol: values.symbol,\n      child_orders,\n    };\n  }\n\n  crateUpdateOrder(\n    values: AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>,\n    /**\n     * The old value of the order\n     */\n    oldValue: API.AlgoOrder,\n    config: ValuesDepConfig\n  ): [\n    { child_orders: AlgoOrderUpdateEntity[] },\n    AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL>\n  ] {\n    const data = this.create(values, config);\n    const newData: {\n      trigger_price?: number;\n      order_id: number;\n      is_activated?: boolean;\n    }[] = [];\n    data.child_orders.forEach((order) => {\n      // find the old order\n\n      const oldOrder = oldValue.child_orders?.find(\n        (oldOrder) => oldOrder.algo_type === order.algo_type\n      );\n\n      if (oldOrder) {\n        if (!order.is_activated) {\n          newData.push({\n            is_activated: false,\n            order_id: Number(oldOrder.algo_order_id),\n          });\n        } else if (oldOrder.trigger_price !== order.trigger_price) {\n          newData.push({\n            trigger_price: order.trigger_price as number,\n            order_id: Number(oldOrder.algo_order_id),\n          });\n        }\n      }\n    });\n\n    return [\n      {\n        child_orders: newData,\n      },\n      data,\n    ];\n  }\n}\n"],"names":["TPSLPositionOrderCreator","BaseAlgoOrderCreator","create","values","config","side","OrderSide","BUY","SELL","child_orders","tp_trigger_price","Decimal","todp","symbol","quote_dp","toNumber","push","algo_type","AlgoOrderType","TAKE_PROFIT","reduce_only","type","OrderType","CLOSE_POSITION","trigger_price","trigger_price_type","TriggerPriceType","MARK_PRICE","is_activated","sl_trigger_price","STOP_LOSS","AlgoOrderRootType","POSITIONAL_TP_SL","crateUpdateOrder","oldValue","data","newData","forEach","order","oldOrder","find","order_id","Number","algo_order_id"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAaaA;;;eAAAA;;;uBAPN;iCAGqD;uBAEpC;AAEjB,MAAMA,iCAAiCC,qCAAoB;IAGhEC,OACEC,MAA2D,EAC3DC,MAAuB,EACvB;QACA,MAAMC,OACJF,OAAOE,IAAI,KAAMC,gBAAS,CAACC,GAAG,GAAGD,gBAAS,CAACE,IAAI,GAAGF,gBAAS,CAACC,GAAG;QAEjE,MAAME,eAAe,EAAE;QAEvB,IAAI,OAAON,OAAOO,gBAAgB,KAAK,aAAa;YAClD,MAAMA,mBAAmB,CAAC,CAACP,OAAOO,gBAAgB,GAC9C,IAAIC,cAAO,CAACR,OAAOO,gBAAgB,EAChCE,IAAI,CAACR,OAAOS,MAAM,CAACC,QAAQ,EAC3BC,QAAQ,KACXZ,OAAOO,gBAAgB;YAE3BD,aAAaO,IAAI,CAAC;gBAChBC,WAAWC,oBAAa,CAACC,WAAW;gBACpCC,aAAa;gBACbf;gBACAgB,MAAMC,gBAAS,CAACC,cAAc;gBAC9BC,eAAed;gBACfe,oBAAoBC,uBAAgB,CAACC,UAAU;gBAC/Cd,QAAQV,OAAOU,MAAM;gBACrBe,cAAc,CAAC,CAACzB,OAAOO,gBAAgB;YACzC;QACF;QAEA,IAAI,OAAOP,OAAO0B,gBAAgB,KAAK,aAAa;YAClD,MAAMA,mBAAmB,CAAC,CAAC1B,OAAO0B,gBAAgB,GAC9C,IAAIlB,cAAO,CAACR,OAAO0B,gBAAgB,EAChCjB,IAAI,CAACR,OAAOS,MAAM,CAACC,QAAQ,EAC3BC,QAAQ,KACXZ,OAAO0B,gBAAgB;YAC3BpB,aAAaO,IAAI,CAAC;gBAChBC,WAAWC,oBAAa,CAACY,SAAS;gBAClCV,aAAa;gBACbf;gBACAgB,MAAMC,gBAAS,CAACC,cAAc;gBAC9BC,eAAeK;gBACfJ,oBAAoBC,uBAAgB,CAACC,UAAU;gBAC/Cd,QAAQV,OAAOU,MAAM;gBACrBe,cAAc,CAAC,CAACzB,OAAO0B,gBAAgB;YACzC;QACF;QAEA,OAAO;YACLZ,WAAWc,wBAAiB,CAACC,gBAAgB;YAC7CP,oBAAoBC,uBAAgB,CAACC,UAAU;YAC/C,qBAAqB;YACrBd,QAAQV,OAAOU,MAAM;YACrBJ;QACF;IACF;IAEAwB,iBACE9B,MAA2D,EAC3D;;KAEC,GACD+B,QAAuB,EACvB9B,MAAuB,EAIvB;QACA,MAAM+B,OAAO,IAAI,CAACjC,MAAM,CAACC,QAAQC;QACjC,MAAMgC,UAIA,EAAE;QACRD,KAAK1B,YAAY,CAAC4B,OAAO,CAAC,CAACC;YACzB,qBAAqB;YAErB,MAAMC,WAAWL,SAASzB,YAAY,EAAE+B,KACtC,CAACD,WAAaA,SAAStB,SAAS,KAAKqB,MAAMrB,SAAS;YAGtD,IAAIsB,UAAU;gBACZ,IAAI,CAACD,MAAMV,YAAY,EAAE;oBACvBQ,QAAQpB,IAAI,CAAC;wBACXY,cAAc;wBACda,UAAUC,OAAOH,SAASI,aAAa;oBACzC;gBACF,OAAO,IAAIJ,SAASf,aAAa,KAAKc,MAAMd,aAAa,EAAE;oBACzDY,QAAQpB,IAAI,CAAC;wBACXQ,eAAec,MAAMd,aAAa;wBAClCiB,UAAUC,OAAOH,SAASI,aAAa;oBACzC;gBACF;YACF;QACF;QAEA,OAAO;YACL;gBACElC,cAAc2B;YAChB;YACAD;SACD;IACH;AACF"}

package/lib/services/orderMerge/algoOrderMergeHandler.d.ts

@@ -0,0 +1,9 @@
+import { API, WSMessage } from "@orderly.network/types";
+import { BaseMergeHandler } from "./baseMergeHandler";
+export declare class AlgoOrderMergeHandler extends BaseMergeHandler<WSMessage.AlgoOrder[], API.AlgoOrder> {
+    get orderId(): number;
+    get status(): string;
+    pre(message: WSMessage.AlgoOrder[], prevData?: API.OrderResponse[]): API.AlgoOrder;
+    static groupOrders(orders: WSMessage.AlgoOrder[]): API.AlgoOrder;
+}
+//# sourceMappingURL=algoOrderMergeHandler.d.ts.map

package/lib/services/orderMerge/algoOrderMergeHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"algoOrderMergeHandler.d.ts","sourceRoot":"","sources":["../../../src/services/orderMerge/algoOrderMergeHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,qBAAa,qBAAsB,SAAQ,gBAAgB,CACzD,SAAS,CAAC,SAAS,EAAE,EACrB,GAAG,CAAC,SAAS,CACd;IACC,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAeD,GAAG,CACD,OAAO,EAAE,SAAS,CAAC,SAAS,EAAE,EAC9B,QAAQ,CAAC,EAAE,GAAG,CAAC,aAAa,EAAE,GAC7B,GAAG,CAAC,SAAS;IAIhB,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,EAAE,GAAG,GAAG,CAAC,SAAS;CAsBjE"}

package/lib/services/orderMerge/algoOrderMergeHandler.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AlgoOrderMergeHandler", {
+    enumerable: true,
+    get: function() {
+        return AlgoOrderMergeHandler;
+    }
+});
+const _baseMergeHandler = require("./baseMergeHandler");
+const _ws = require("../../utils/ws");
+class AlgoOrderMergeHandler extends _baseMergeHandler.BaseMergeHandler {
+    get orderId() {
+        return this.data.algo_order_id;
+    }
+    get status() {
+        return this.data.root_algo_status;
+    }
+    //   merge(
+    //     key: string,
+    //     message: WSMessage.AlgoOrder[],
+    //     prevData: API.OrderResponse[]
+    //   ): API.OrderResponse[] | undefined {
+    //     switch (this.status) {
+    //       case "TRIGGER": {
+    //       }
+    //       default:
+    //         return super.merge(key, message, prevData);
+    //     }
+    //   }
+    pre(message, prevData) {
+        return AlgoOrderMergeHandler.groupOrders(message);
+    }
+    static groupOrders(orders) {
+        const rootOrderIndex = orders.findIndex((order)=>order.parentAlgoOrderId === 0 && order.algoOrderId === order.rootAlgoOrderId);
+        if (rootOrderIndex === -1) {
+            throw new Error("Root order not found");
+        }
+        const rootOrder_ = (0, _ws.object2underscore)(orders[rootOrderIndex]);
+        rootOrder_.child_orders = orders.filter((_, index)=>index !== rootOrderIndex).map((order)=>{
+            return (0, _ws.object2underscore)(order);
+        });
+        return rootOrder_;
+    }
+}
+
+//# sourceMappingURL=algoOrderMergeHandler.js.map

package/lib/services/orderMerge/algoOrderMergeHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/orderMerge/algoOrderMergeHandler.ts"],"sourcesContent":["import { API, WSMessage } from \"@orderly.network/types\";\nimport { BaseMergeHandler } from \"./baseMergeHandler\";\nimport { object2underscore } from \"../../utils/ws\";\n\nexport class AlgoOrderMergeHandler extends BaseMergeHandler<\n  WSMessage.AlgoOrder[],\n  API.AlgoOrder\n> {\n  get orderId(): number {\n    return this.data.algo_order_id;\n  }\n\n  get status(): string {\n    return this.data.root_algo_status;\n  }\n\n  //   merge(\n  //     key: string,\n  //     message: WSMessage.AlgoOrder[],\n  //     prevData: API.OrderResponse[]\n  //   ): API.OrderResponse[] | undefined {\n  //     switch (this.status) {\n  //       case \"TRIGGER\": {\n  //       }\n  //       default:\n  //         return super.merge(key, message, prevData);\n  //     }\n  //   }\n\n  pre(\n    message: WSMessage.AlgoOrder[],\n    prevData?: API.OrderResponse[]\n  ): API.AlgoOrder {\n    return AlgoOrderMergeHandler.groupOrders(message);\n  }\n\n  static groupOrders(orders: WSMessage.AlgoOrder[]): API.AlgoOrder {\n    const rootOrderIndex = orders.findIndex(\n      (order) =>\n        order.parentAlgoOrderId === 0 &&\n        order.algoOrderId === order.rootAlgoOrderId\n    );\n    if (rootOrderIndex === -1) {\n      throw new Error(\"Root order not found\");\n    }\n\n    const rootOrder_ = object2underscore(\n      orders[rootOrderIndex]\n    ) as unknown as API.AlgoOrder;\n\n    rootOrder_.child_orders = orders\n      .filter((_, index) => index !== rootOrderIndex)\n      .map((order) => {\n        return object2underscore(order) as unknown as API.AlgoOrder;\n      });\n\n    return rootOrder_;\n  }\n}\n"],"names":["AlgoOrderMergeHandler","BaseMergeHandler","orderId","data","algo_order_id","status","root_algo_status","pre","message","prevData","groupOrders","orders","rootOrderIndex","findIndex","order","parentAlgoOrderId","algoOrderId","rootAlgoOrderId","Error","rootOrder_","object2underscore","child_orders","filter","_","index","map"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;kCAHoB;oBACC;AAE3B,MAAMA,8BAA8BC,kCAAgB;IAIzD,IAAIC,UAAkB;QACpB,OAAO,IAAI,CAACC,IAAI,CAACC,aAAa;IAChC;IAEA,IAAIC,SAAiB;QACnB,OAAO,IAAI,CAACF,IAAI,CAACG,gBAAgB;IACnC;IAEA,WAAW;IACX,mBAAmB;IACnB,sCAAsC;IACtC,oCAAoC;IACpC,yCAAyC;IACzC,6BAA6B;IAC7B,0BAA0B;IAC1B,UAAU;IACV,iBAAiB;IACjB,sDAAsD;IACtD,QAAQ;IACR,MAAM;IAENC,IACEC,OAA8B,EAC9BC,QAA8B,EACf;QACf,OAAOT,sBAAsBU,WAAW,CAACF;IAC3C;IAEA,OAAOE,YAAYC,MAA6B,EAAiB;QAC/D,MAAMC,iBAAiBD,OAAOE,SAAS,CACrC,CAACC,QACCA,MAAMC,iBAAiB,KAAK,KAC5BD,MAAME,WAAW,KAAKF,MAAMG,eAAe;QAE/C,IAAIL,mBAAmB,CAAC,GAAG;YACzB,MAAM,IAAIM,MAAM;QAClB;QAEA,MAAMC,aAAaC,IAAAA,qBAAiB,EAClCT,MAAM,CAACC,eAAe;QAGxBO,WAAWE,YAAY,GAAGV,OACvBW,MAAM,CAAC,CAACC,GAAGC,QAAUA,UAAUZ,gBAC/Ba,GAAG,CAAC,CAACX;YACJ,OAAOM,IAAAA,qBAAiB,EAACN;QAC3B;QAEF,OAAOK;IACT;AACF"}

package/lib/services/orderMerge/baseMergeHandler.d.ts

@@ -0,0 +1,22 @@
+import { WSMessage, API } from "@orderly.network/types";
+import { IOrderMergeHandler } from "./interface";
+export declare abstract class BaseMergeHandler<T extends WSMessage.AlgoOrder[] | WSMessage.Order, D extends API.AlgoOrder | API.Order> implements IOrderMergeHandler<T, D> {
+    private message;
+    data: D;
+    constructor(message: T);
+    abstract get status(): string;
+    abstract get orderId(): number;
+    abstract pre(message: T, prevData?: API.OrderResponse[]): D;
+    /**
+     * format the order data;
+     */
+    formatOrder(message: T): D;
+    merge(key: string, message: T, prevData: API.OrderResponse[]): API.OrderResponse[];
+    insert(orders?: API.OrderResponse[] | undefined): API.OrderResponse[];
+    insetOrUpdate(orders: API.OrderResponse[]): API.OrderResponse[];
+    update(prevData: API.OrderResponse[]): API.OrderResponse[];
+    remove(prevData: API.OrderResponse[]): API.OrderResponse[];
+    findOrderIndex(orders: API.OrderResponse[]): number[] | undefined;
+    orderIsExisting(orders: API.OrderResponse[]): boolean;
+}
+//# sourceMappingURL=baseMergeHandler.d.ts.map

package/lib/services/orderMerge/baseMergeHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseMergeHandler.d.ts","sourceRoot":"","sources":["../../../src/services/orderMerge/baseMergeHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGjD,8BAAsB,gBAAgB,CACpC,CAAC,SAAS,SAAS,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,KAAK,EACjD,CAAC,SAAS,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,KAAK,CACnC,YAAW,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;IAGvB,OAAO,CAAC,OAAO;IAD3B,IAAI,EAAE,CAAC,CAAC;gBACY,OAAO,EAAE,CAAC;IAG9B,QAAQ,KAAK,MAAM,IAAI,MAAM,CAAC;IAC9B,QAAQ,KAAK,OAAO,IAAI,MAAM,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,CAAC;IAE3D;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC;IAc1B,KAAK,CACH,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,EACV,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAC5B,GAAG,CAAC,aAAa,EAAE;IA0EtB,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,SAAS,GAAG,GAAG,CAAC,aAAa,EAAE;IAgBrE,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,GAAG,CAAC,aAAa,EAAE;IAO/D,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,GAAG,CAAC,aAAa,EAAE;IAqB1D,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,GAAG,CAAC,aAAa,EAAE;IAiB1D,cAAc,CAAC,MAAM,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS;IA+BjE,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,OAAO;CAItD"}

package/lib/services/orderMerge/baseMergeHandler.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BaseMergeHandler", {
+    enumerable: true,
+    get: function() {
+        return BaseMergeHandler;
+    }
+});
+const _ramda = require("ramda");
+class BaseMergeHandler {
+    message;
+    data;
+    constructor(message){
+        this.message = message;
+        this.data = this.formatOrder(message);
+    }
+    /**
+   * format the order data;
+   */ formatOrder(message) {
+        const data = this.pre(message);
+        if (!data.created_time) {
+            data.created_time = data.timestamp;
+        }
+        if (data.type && data.type.endsWith("_ORDER")) {
+            data.type = data.type.replace("_ORDER", "");
+        }
+        return data;
+    }
+    merge(key, message, prevData) {
+        switch(this.status){
+            case "NEW":
+                {
+                    if (key.startsWith("orders:CANCELLED") || key.startsWith("orders:FILLED") || key.startsWith("orders:REJECTED")) {
+                        return prevData;
+                    }
+                    return this.insetOrUpdate(prevData);
+                }
+            case "CANCELLED":
+                {
+                    if (key.startsWith("orders:FILLED") || key.startsWith("orders:REJECTED")) {
+                        return prevData;
+                    }
+                    if (key.startsWith("orders:NEW") || key.startsWith("orders:INCOMPLETE")) {
+                        return this.remove(prevData);
+                    }
+                    if (key.startsWith("orders:CANCELLED")) {
+                        return this.insert(prevData);
+                    }
+                    return this.update(prevData);
+                }
+            case "REPLACED":
+                return this.update(prevData);
+            case "FILLED":
+                {
+                    if (this.orderIsExisting(prevData)) {
+                        // for new list, remove the order if it exists
+                        if (key.startsWith("orders:INCOMPLETE") || key.startsWith("orders:NEW")) {
+                            // if fullfilled, remove from the list
+                            if ("total_executed_quantity" in this.data && this.data.total_executed_quantity === this.data.quantity) {
+                                return this.remove(prevData);
+                            }
+                            // update
+                            return this.update(prevData);
+                        }
+                    } else {
+                        // for filled list, insert the order if it doesn't exist
+                        if (key.startsWith("orders:CANCELLED") || key.startsWith("orders:INCOMPLETE") || key.startsWith("orders:NEW")) {
+                            return prevData;
+                        }
+                        // if filled/history list:
+                        return this.insert(prevData);
+                    }
+                }
+            default:
+                return prevData || [];
+        }
+    }
+    insert(orders) {
+        const index = (0, _ramda.lensIndex)(0);
+        return (0, _ramda.over)(//@ts-ignore
+        index, (item)=>({
+                meta: {
+                    ...item.meta,
+                    total: item.meta.total + 1
+                },
+                rows: [
+                    this.data,
+                    ...item.rows
+                ]
+            }), orders);
+    }
+    insetOrUpdate(orders) {
+        if (this.orderIsExisting(orders)) {
+            return this.update(orders);
+        }
+        return this.insert(orders);
+    }
+    update(prevData) {
+        const idx = this.findOrderIndex(prevData);
+        if (!Array.isArray(idx)) {
+            return prevData || [];
+        }
+        const [index, index2] = idx;
+        return prevData.map((item, i)=>{
+            return {
+                meta: {
+                    ...item.meta
+                },
+                rows: item.rows.map((order, j)=>{
+                    if (index === i && index2 === j) {
+                        return {
+                            ...order,
+                            ...this.data
+                        };
+                    }
+                    return order;
+                })
+            };
+        });
+    }
+    remove(prevData) {
+        const idx = this.findOrderIndex(prevData);
+        if (!Array.isArray(idx)) {
+            return prevData;
+        }
+        const [index, index2] = idx;
+        return prevData.map((item, i)=>{
+            return {
+                meta: {
+                    ...item.meta,
+                    total: item.meta.total - 1
+                },
+                rows: index === i ? item.rows.filter((_, i)=>i !== index2) : item.rows
+            };
+        });
+    }
+    findOrderIndex(orders) {
+        let index = 0;
+        let index2;
+        for(; index < orders.length; index++){
+            // index = idx;
+            const item = orders[index];
+            for(let idx2 = 0; idx2 < item.rows.length; idx2++){
+                const element = item.rows[idx2];
+                if (element.algo_order_id === this.orderId || element.order_id === this.orderId) {
+                    index2 = idx2;
+                    break;
+                }
+            }
+            if (typeof index2 !== "undefined") {
+                break;
+            }
+        }
+        if (typeof index2 === "undefined") {
+            return;
+        }
+        return [
+            index,
+            index2
+        ];
+    }
+    orderIsExisting(orders) {
+        const index = this.findOrderIndex(orders);
+        return Array.isArray(index);
+    }
+}
+
+//# sourceMappingURL=baseMergeHandler.js.map

package/lib/services/orderMerge/baseMergeHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/orderMerge/baseMergeHandler.ts"],"sourcesContent":["import { WSMessage, API } from \"@orderly.network/types\";\nimport { IOrderMergeHandler } from \"./interface\";\nimport { lensIndex, over } from \"ramda\";\n\nexport abstract class BaseMergeHandler<\n  T extends WSMessage.AlgoOrder[] | WSMessage.Order,\n  D extends API.AlgoOrder | API.Order\n> implements IOrderMergeHandler<T, D>\n{\n  data: D;\n  constructor(private message: T) {\n    this.data = this.formatOrder(message);\n  }\n  abstract get status(): string;\n  abstract get orderId(): number;\n  abstract pre(message: T, prevData?: API.OrderResponse[]): D;\n\n  /**\n   * format the order data;\n   */\n  formatOrder(message: T): D {\n    const data = this.pre(message);\n\n    if (!data.created_time) {\n      data.created_time = (data as any).timestamp;\n    }\n\n    if (data.type && data.type.endsWith(\"_ORDER\")) {\n      data.type = data.type.replace(\"_ORDER\", \"\");\n    }\n\n    return data;\n  }\n\n  merge(\n    key: string,\n    message: T,\n    prevData: API.OrderResponse[]\n  ): API.OrderResponse[] {\n    switch (this.status) {\n      case \"NEW\": {\n        if (\n          key.startsWith(\"orders:CANCELLED\") ||\n          key.startsWith(\"orders:FILLED\") ||\n          key.startsWith(\"orders:REJECTED\")\n        ) {\n          return prevData;\n        }\n        return this.insetOrUpdate(prevData);\n      }\n      case \"CANCELLED\": {\n        if (\n          key.startsWith(\"orders:FILLED\") ||\n          key.startsWith(\"orders:REJECTED\")\n        ) {\n          return prevData;\n        }\n        if (\n          key.startsWith(\"orders:NEW\") ||\n          key.startsWith(\"orders:INCOMPLETE\")\n        ) {\n          return this.remove(prevData);\n        }\n\n        if (key.startsWith(\"orders:CANCELLED\")) {\n          return this.insert(prevData);\n        }\n\n        return this.update(prevData);\n      }\n\n      case \"REPLACED\":\n        return this.update(prevData);\n\n      case \"FILLED\": {\n        if (this.orderIsExisting(prevData)) {\n          // for new list, remove the order if it exists\n          if (\n            key.startsWith(\"orders:INCOMPLETE\") ||\n            key.startsWith(\"orders:NEW\")\n          ) {\n            // if fullfilled, remove from the list\n            if (\n              \"total_executed_quantity\" in this.data &&\n              this.data.total_executed_quantity === this.data.quantity\n            ) {\n              return this.remove(prevData);\n            }\n\n            // update\n            return this.update(prevData);\n          }\n        } else {\n          // for filled list, insert the order if it doesn't exist\n\n          if (\n            key.startsWith(\"orders:CANCELLED\") ||\n            key.startsWith(\"orders:INCOMPLETE\") ||\n            key.startsWith(\"orders:NEW\")\n          ) {\n            return prevData;\n          }\n          // if filled/history list:\n          return this.insert(prevData);\n        }\n      }\n\n      default:\n        return prevData || [];\n    }\n  }\n\n  insert(orders?: API.OrderResponse[] | undefined): API.OrderResponse[] {\n    const index = lensIndex<API.OrderResponse>(0);\n    return over(\n      //@ts-ignore\n      index,\n      (item: any) => ({\n        meta: {\n          ...item.meta,\n          total: item.meta.total + 1,\n        },\n        rows: [this.data, ...item.rows],\n      }),\n      orders\n    ) as API.OrderResponse[];\n  }\n\n  insetOrUpdate(orders: API.OrderResponse[]): API.OrderResponse[] {\n    if (this.orderIsExisting(orders)) {\n      return this.update(orders);\n    }\n    return this.insert(orders);\n  }\n\n  update(prevData: API.OrderResponse[]): API.OrderResponse[] {\n    const idx = this.findOrderIndex(prevData);\n    if (!Array.isArray(idx)) {\n      return prevData || [];\n    }\n\n    const [index, index2] = idx;\n\n    return prevData.map((item, i) => {\n      return {\n        meta: { ...item.meta },\n        rows: item.rows.map((order, j) => {\n          if (index === i && index2 === j) {\n            return { ...order, ...this.data };\n          }\n          return order;\n        }),\n      };\n    });\n  }\n\n  remove(prevData: API.OrderResponse[]): API.OrderResponse[] {\n    const idx = this.findOrderIndex(prevData);\n    if (!Array.isArray(idx)) {\n      return prevData;\n    }\n\n    const [index, index2] = idx;\n\n    return prevData.map((item, i) => {\n      return {\n        meta: { ...item.meta, total: item.meta.total - 1 },\n        rows:\n          index === i ? item.rows.filter((_, i) => i !== index2) : item.rows,\n      };\n    });\n  }\n\n  findOrderIndex(orders: API.OrderResponse[]): number[] | undefined {\n    let index: number = 0;\n    let index2: number | undefined;\n\n    for (; index < orders.length; index++) {\n      // index = idx;\n      const item = orders[index];\n\n      for (let idx2 = 0; idx2 < item.rows.length; idx2++) {\n        const element = item.rows[idx2];\n        if (\n          (element as API.AlgoOrder).algo_order_id === this.orderId ||\n          (element as API.Order).order_id === this.orderId\n        ) {\n          index2 = idx2;\n\n          break;\n        }\n      }\n      if (typeof index2 !== \"undefined\") {\n        break;\n      }\n    }\n\n    if (typeof index2 === \"undefined\") {\n      return;\n    }\n\n    return [index, index2];\n  }\n\n  orderIsExisting(orders: API.OrderResponse[]): boolean {\n    const index = this.findOrderIndex(orders);\n    return Array.isArray(index);\n  }\n}\n"],"names":["BaseMergeHandler","data","constructor","message","formatOrder","pre","created_time","timestamp","type","endsWith","replace","merge","key","prevData","status","startsWith","insetOrUpdate","remove","insert","update","orderIsExisting","total_executed_quantity","quantity","orders","index","lensIndex","over","item","meta","total","rows","idx","findOrderIndex","Array","isArray","index2","map","i","order","j","filter","_","length","idx2","element","algo_order_id","orderId","order_id"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIsBA;;;eAAAA;;;uBAFU;AAEzB,MAAeA;;IAKpBC,KAAQ;IACRC,YAAY,AAAQC,OAAU,CAAE;aAAZA,UAAAA;QAClB,IAAI,CAACF,IAAI,GAAG,IAAI,CAACG,WAAW,CAACD;IAC/B;IAKA;;GAEC,GACDC,YAAYD,OAAU,EAAK;QACzB,MAAMF,OAAO,IAAI,CAACI,GAAG,CAACF;QAEtB,IAAI,CAACF,KAAKK,YAAY,EAAE;YACtBL,KAAKK,YAAY,GAAG,AAACL,KAAaM,SAAS;QAC7C;QAEA,IAAIN,KAAKO,IAAI,IAAIP,KAAKO,IAAI,CAACC,QAAQ,CAAC,WAAW;YAC7CR,KAAKO,IAAI,GAAGP,KAAKO,IAAI,CAACE,OAAO,CAAC,UAAU;QAC1C;QAEA,OAAOT;IACT;IAEAU,MACEC,GAAW,EACXT,OAAU,EACVU,QAA6B,EACR;QACrB,OAAQ,IAAI,CAACC,MAAM;YACjB,KAAK;gBAAO;oBACV,IACEF,IAAIG,UAAU,CAAC,uBACfH,IAAIG,UAAU,CAAC,oBACfH,IAAIG,UAAU,CAAC,oBACf;wBACA,OAAOF;oBACT;oBACA,OAAO,IAAI,CAACG,aAAa,CAACH;gBAC5B;YACA,KAAK;gBAAa;oBAChB,IACED,IAAIG,UAAU,CAAC,oBACfH,IAAIG,UAAU,CAAC,oBACf;wBACA,OAAOF;oBACT;oBACA,IACED,IAAIG,UAAU,CAAC,iBACfH,IAAIG,UAAU,CAAC,sBACf;wBACA,OAAO,IAAI,CAACE,MAAM,CAACJ;oBACrB;oBAEA,IAAID,IAAIG,UAAU,CAAC,qBAAqB;wBACtC,OAAO,IAAI,CAACG,MAAM,CAACL;oBACrB;oBAEA,OAAO,IAAI,CAACM,MAAM,CAACN;gBACrB;YAEA,KAAK;gBACH,OAAO,IAAI,CAACM,MAAM,CAACN;YAErB,KAAK;gBAAU;oBACb,IAAI,IAAI,CAACO,eAAe,CAACP,WAAW;wBAClC,8CAA8C;wBAC9C,IACED,IAAIG,UAAU,CAAC,wBACfH,IAAIG,UAAU,CAAC,eACf;4BACA,sCAAsC;4BACtC,IACE,6BAA6B,IAAI,CAACd,IAAI,IACtC,IAAI,CAACA,IAAI,CAACoB,uBAAuB,KAAK,IAAI,CAACpB,IAAI,CAACqB,QAAQ,EACxD;gCACA,OAAO,IAAI,CAACL,MAAM,CAACJ;4BACrB;4BAEA,SAAS;4BACT,OAAO,IAAI,CAACM,MAAM,CAACN;wBACrB;oBACF,OAAO;wBACL,wDAAwD;wBAExD,IACED,IAAIG,UAAU,CAAC,uBACfH,IAAIG,UAAU,CAAC,wBACfH,IAAIG,UAAU,CAAC,eACf;4BACA,OAAOF;wBACT;wBACA,0BAA0B;wBAC1B,OAAO,IAAI,CAACK,MAAM,CAACL;oBACrB;gBACF;YAEA;gBACE,OAAOA,YAAY,EAAE;QACzB;IACF;IAEAK,OAAOK,MAAwC,EAAuB;QACpE,MAAMC,QAAQC,IAAAA,gBAAS,EAAoB;QAC3C,OAAOC,IAAAA,WAAI,EACT,YAAY;QACZF,OACA,CAACG,OAAe,CAAA;gBACdC,MAAM;oBACJ,GAAGD,KAAKC,IAAI;oBACZC,OAAOF,KAAKC,IAAI,CAACC,KAAK,GAAG;gBAC3B;gBACAC,MAAM;oBAAC,IAAI,CAAC7B,IAAI;uBAAK0B,KAAKG,IAAI;iBAAC;YACjC,CAAA,GACAP;IAEJ;IAEAP,cAAcO,MAA2B,EAAuB;QAC9D,IAAI,IAAI,CAACH,eAAe,CAACG,SAAS;YAChC,OAAO,IAAI,CAACJ,MAAM,CAACI;QACrB;QACA,OAAO,IAAI,CAACL,MAAM,CAACK;IACrB;IAEAJ,OAAON,QAA6B,EAAuB;QACzD,MAAMkB,MAAM,IAAI,CAACC,cAAc,CAACnB;QAChC,IAAI,CAACoB,MAAMC,OAAO,CAACH,MAAM;YACvB,OAAOlB,YAAY,EAAE;QACvB;QAEA,MAAM,CAACW,OAAOW,OAAO,GAAGJ;QAExB,OAAOlB,SAASuB,GAAG,CAAC,CAACT,MAAMU;YACzB,OAAO;gBACLT,MAAM;oBAAE,GAAGD,KAAKC,IAAI;gBAAC;gBACrBE,MAAMH,KAAKG,IAAI,CAACM,GAAG,CAAC,CAACE,OAAOC;oBAC1B,IAAIf,UAAUa,KAAKF,WAAWI,GAAG;wBAC/B,OAAO;4BAAE,GAAGD,KAAK;4BAAE,GAAG,IAAI,CAACrC,IAAI;wBAAC;oBAClC;oBACA,OAAOqC;gBACT;YACF;QACF;IACF;IAEArB,OAAOJ,QAA6B,EAAuB;QACzD,MAAMkB,MAAM,IAAI,CAACC,cAAc,CAACnB;QAChC,IAAI,CAACoB,MAAMC,OAAO,CAACH,MAAM;YACvB,OAAOlB;QACT;QAEA,MAAM,CAACW,OAAOW,OAAO,GAAGJ;QAExB,OAAOlB,SAASuB,GAAG,CAAC,CAACT,MAAMU;YACzB,OAAO;gBACLT,MAAM;oBAAE,GAAGD,KAAKC,IAAI;oBAAEC,OAAOF,KAAKC,IAAI,CAACC,KAAK,GAAG;gBAAE;gBACjDC,MACEN,UAAUa,IAAIV,KAAKG,IAAI,CAACU,MAAM,CAAC,CAACC,GAAGJ,IAAMA,MAAMF,UAAUR,KAAKG,IAAI;YACtE;QACF;IACF;IAEAE,eAAeT,MAA2B,EAAwB;QAChE,IAAIC,QAAgB;QACpB,IAAIW;QAEJ,MAAOX,QAAQD,OAAOmB,MAAM,EAAElB,QAAS;YACrC,eAAe;YACf,MAAMG,OAAOJ,MAAM,CAACC,MAAM;YAE1B,IAAK,IAAImB,OAAO,GAAGA,OAAOhB,KAAKG,IAAI,CAACY,MAAM,EAAEC,OAAQ;gBAClD,MAAMC,UAAUjB,KAAKG,IAAI,CAACa,KAAK;gBAC/B,IACE,AAACC,QAA0BC,aAAa,KAAK,IAAI,CAACC,OAAO,IACzD,AAACF,QAAsBG,QAAQ,KAAK,IAAI,CAACD,OAAO,EAChD;oBACAX,SAASQ;oBAET;gBACF;YACF;YACA,IAAI,OAAOR,WAAW,aAAa;gBACjC;YACF;QACF;QAEA,IAAI,OAAOA,WAAW,aAAa;YACjC;QACF;QAEA,OAAO;YAACX;YAAOW;SAAO;IACxB;IAEAf,gBAAgBG,MAA2B,EAAW;QACpD,MAAMC,QAAQ,IAAI,CAACQ,cAAc,CAACT;QAClC,OAAOU,MAAMC,OAAO,CAACV;IACvB;AACF"}

package/lib/services/orderMerge/interface.d.ts

@@ -0,0 +1,8 @@
+import { API } from "@orderly.network/types";
+export interface IOrderMergeHandler<T, D> {
+    merge(key: string, updatedOrder: T, prevData: API.OrderResponse[]): API.OrderResponse[];
+    insert(prevData: API.OrderResponse[]): API.OrderResponse[];
+    update(prevData: API.OrderResponse[]): API.OrderResponse[];
+    remove(prevData: API.OrderResponse[]): API.OrderResponse[];
+}
+//# sourceMappingURL=interface.d.ts.map

package/lib/services/orderMerge/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/services/orderMerge/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAa,MAAM,wBAAwB,CAAC;AAExD,MAAM,WAAW,kBAAkB,CAAC,CAAC,EAAE,CAAC;IACtC,KAAK,CACH,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,EACf,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAC5B,GAAG,CAAC,aAAa,EAAE,CAAC;IACvB,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,GAAG,CAAC,aAAa,EAAE,CAAC;IAC3D,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,GAAG,CAAC,aAAa,EAAE,CAAC;IAC3D,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,GAAG,CAAC,aAAa,EAAE,CAAC;CAC5D"}

package/lib/services/orderMerge/interface.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=interface.js.map

package/lib/services/orderMerge/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/orderMerge/interface.ts"],"names":[],"rangeMappings":"","mappings":""}

package/lib/services/orderMerge/regularOrderMergeHandler.d.ts

@@ -0,0 +1,8 @@
+import { API, WSMessage } from "@orderly.network/types";
+import { BaseMergeHandler } from "./baseMergeHandler";
+export declare class RegularOrderMergeHandler extends BaseMergeHandler<WSMessage.Order, API.Order> {
+    get orderId(): number;
+    get status(): string;
+    pre(message: WSMessage.Order, prevData?: API.OrderResponse[] | undefined): API.Order;
+}
+//# sourceMappingURL=regularOrderMergeHandler.d.ts.map

package/lib/services/orderMerge/regularOrderMergeHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regularOrderMergeHandler.d.ts","sourceRoot":"","sources":["../../../src/services/orderMerge/regularOrderMergeHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,qBAAa,wBAAyB,SAAQ,gBAAgB,CAC5D,SAAS,CAAC,KAAK,EACf,GAAG,CAAC,KAAK,CACV;IACC,IAAI,OAAO,IAAI,MAAM,CAEpB;IACD,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD,GAAG,CACD,OAAO,EAAE,SAAS,CAAC,KAAK,EACxB,QAAQ,CAAC,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,SAAS,GACzC,GAAG,CAAC,KAAK;CAGb"}