@pipedream/bitmex 0.0.1 → 0.1.0

package/actions/create-order/create-order.mjs

@@ -0,0 +1,168 @@
+import bitmex from "../../bitmex.app.mjs";
+
+export default {
+  key: "bitmex-create-order",
+  name: "Create Order",
+  description: "Submit a new trading order in your BitMEX account. [See the documentation](https://www.bitmex.com/api/explorer/#!/Order/Order_new)",
+  version: "0.0.1",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: false,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    bitmex,
+    symbol: {
+      propDefinition: [
+        bitmex,
+        "symbol",
+      ],
+    },
+    strategy: {
+      type: "string",
+      label: "Strategy",
+      description: "Order strategy. e.g. 'OneWay', 'Long', 'Short'",
+      optional: true,
+    },
+    side: {
+      type: "string",
+      label: "Side",
+      description: "Order side. Valid options: Buy, Sell. Defaults to 'Buy' unless `orderQty` is negative",
+      optional: true,
+      options: [
+        "Buy",
+        "Sell",
+      ],
+    },
+    orderQty: {
+      type: "integer",
+      label: "Order Quantity",
+      description: "Order quantity in units of the instrument (i.e. contracts, for spot it is base currency in minor currency for spot (e.g. XBt quantity for XBT))",
+      optional: true,
+    },
+    price: {
+      type: "string",
+      label: "Price",
+      description: "Optional limit price for 'Limit', 'StopLimit', and 'LimitIfTouched' orders",
+      optional: true,
+    },
+    displayQty: {
+      type: "integer",
+      label: "Display Quantity",
+      description: "Optional quantity to display in the book. Use 0 for a fully hidden order.",
+      optional: true,
+    },
+    stopPx: {
+      type: "string",
+      label: "Stop Price",
+      description: "Optional trigger price for 'Stop', 'StopLimit', 'MarketIfTouched', and 'LimitIfTouched' orders. Use a price below the current price for stop-sell orders and buy-if-touched orders. Use `execInst` of 'MarkPrice' or 'LastPrice' to define the current price used for triggering.",
+      optional: true,
+    },
+    clOrdID: {
+      type: "string",
+      label: "Client Order ID",
+      description: "Optional Client Order ID. This clOrdID will come back on the order and any related executions.",
+      optional: true,
+    },
+    clOrdLinkID: {
+      type: "string",
+      label: "Client Order Link ID",
+      description: "Optional Client Order Link ID for contingent orders",
+      optional: true,
+    },
+    pegOffsetValue: {
+      type: "string",
+      label: "Peg Offset Value",
+      description: "Optional trailing offset from the current price for 'Stop', 'StopLimit', 'MarketIfTouched', and 'LimitIfTouched' orders; use a negative offset for stop-sell orders and buy-if-touched orders. Optional offset from the peg price for 'Pegged' orders.",
+      optional: true,
+    },
+    pegPriceType: {
+      type: "string",
+      label: "Peg Price Type",
+      description: "Optional peg price type. Valid options: MarketPeg, PrimaryPeg, TrailingStopPeg",
+      optional: true,
+      options: [
+        "MarketPeg",
+        "PrimaryPeg",
+        "TrailingStopPeg",
+      ],
+    },
+    ordType: {
+      type: "string",
+      label: "Order Type",
+      description: "Order type. Valid options: Market, Limit, Stop, StopLimit, MarketIfTouched, LimitIfTouched, Pegged. Defaults to 'Limit' when `price` is specified. Defaults to 'Stop' when `stopPx` is specified. Defaults to 'StopLimit' when `price` and `stopPx` are specified.",
+      optional: true,
+      default: "Limit",
+      options: [
+        "Market",
+        "Limit",
+        "Stop",
+        "StopLimit",
+        "MarketIfTouched",
+        "LimitIfTouched",
+        "Pegged",
+      ],
+    },
+    timeInForce: {
+      type: "string",
+      label: "Time In Force",
+      description: "Time in force. Valid options: Day, GoodTillCancel, ImmediateOrCancel, FillOrKill. Defaults to 'GoodTillCancel' for 'Limit', 'StopLimit', and 'LimitIfTouched' orders.",
+      optional: true,
+      options: [
+        "Day",
+        "GoodTillCancel",
+        "ImmediateOrCancel",
+        "FillOrKill",
+      ],
+    },
+    execInst: {
+      type: "string",
+      label: "Execution Instructions",
+      description: "Optional execution instructions. Valid options: ParticipateDoNotInitiate, AllOrNone, MarkPrice, IndexPrice, LastPrice, Close, ReduceOnly, Fixed, LastWithinMark. 'AllOrNone' instruction requires `displayQty` to be 0. 'MarkPrice', 'IndexPrice' or 'LastPrice' instruction valid for 'Stop', 'StopLimit', 'MarketIfTouched', and 'LimitIfTouched' orders. 'LastWithinMark' instruction valid for 'Stop' and 'StopLimit' with instruction 'LastPrice'. IndexPrice, LastWithMark, Close and ReduceOnly are not applicable to spot trading symbols.",
+      optional: true,
+    },
+    contingencyType: {
+      type: "string",
+      label: "Contingency Type",
+      description: "Optional contingency type for use with `clOrdLinkID`. Valid options: OneCancelsTheOther, OneTriggersTheOther.",
+      optional: true,
+      options: [
+        "OneCancelsTheOther",
+        "OneTriggersTheOther",
+      ],
+    },
+    text: {
+      type: "string",
+      label: "Text",
+      description: "Optional order annotation. e.g. 'Take profit'",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.bitmex.createOrder({
+      symbol: this.symbol,
+      strategy: this.strategy,
+      side: this.side,
+      orderQty: this.orderQty,
+      price: this.price,
+      displayQty: this.displayQty,
+      stopPx: this.stopPx,
+      clOrdID: this.clOrdID,
+      clOrdLinkID: this.clOrdLinkID,
+      pegOffsetValue: this.pegOffsetValue,
+      pegPriceType: this.pegPriceType,
+      ordType: this.ordType,
+      timeInForce: this.timeInForce,
+      execInst: this.execInst,
+      contingencyType: this.contingencyType,
+      text: this.text,
+    });
+
+    $.export("$summary", `Successfully created order${response.orderID
+      ? ` with ID: ${response.orderID}`
+      : ""}`);
+    return response;
+  },
+};
+

package/actions/get-user-wallet/get-user-wallet.mjs

@@ -0,0 +1,33 @@
+import bitmex from "../../bitmex.app.mjs";
+
+export default {
+  key: "bitmex-get-user-wallet",
+  name: "Get User Wallet",
+  description: "Retrieve your current wallet information from BitMEX. [See the documentation](https://www.bitmex.com/api/explorer/#!/User/User_getWallet)",
+  version: "0.0.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: false,
+    readOnlyHint: true,
+  },
+  type: "action",
+  props: {
+    bitmex,
+    currency: {
+      propDefinition: [
+        bitmex,
+        "currency",
+      ],
+      description: "Any currency symbol, such as \"XBt\" or \"USDt\". For all currencies specify \"all\". Defaults to \"XBt\"",
+      default: "XBt",
+    },
+  },
+  async run({ $ }) {
+    const response = await this.bitmex.getUserWallet({
+      currency: this.currency,
+    });
+
+    $.export("$summary", `Successfully retrieved wallet information for currency: ${this.currency}`);
+    return response;
+  },
+};

package/actions/list-trades/list-trades.mjs

@@ -0,0 +1,103 @@
+import bitmex from "../../bitmex.app.mjs";
+
+export default {
+  key: "bitmex-list-trades",
+  name: "List Trades",
+  description: "Retrieve a list of executed trades from your BitMEX account. [See the documentation](https://www.bitmex.com/api/explorer/#!/Execution/Execution_getTradeHistory)",
+  version: "0.0.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: false,
+    readOnlyHint: true,
+  },
+  type: "action",
+  props: {
+    bitmex,
+    filter: {
+      type: "object",
+      label: "Filter",
+      description: "Generic table filter. Send JSON key/value pairs, such as `{\"execType\": [\"Settlement\", \"Trade\"]}` to filter on multiple values. For explanations on filters refer to http://www.onixs.biz/fix-dictionary/5.0.SP2/msgType_8_8.html",
+      optional: true,
+    },
+    symbol: {
+      propDefinition: [
+        bitmex,
+        "symbol",
+      ],
+      optional: true,
+    },
+    columns: {
+      type: "string[]",
+      label: "Columns",
+      description: "Array of column names to fetch. If omitted, will return all columns. Note that this method will always return item keys, even when not specified, so you may receive more columns that you expect.",
+      optional: true,
+    },
+    count: {
+      type: "integer",
+      label: "Count",
+      description: "Number of results to fetch. Must be a positive integer. Defaults to 100",
+      optional: true,
+      default: 100,
+    },
+    start: {
+      type: "integer",
+      label: "Start",
+      description: "Starting point for results. Defaults to 0",
+      optional: true,
+      default: 0,
+    },
+    reverse: {
+      type: "boolean",
+      label: "Reverse",
+      description: "If `true`, will sort results newest first. Defaults to `false`",
+      optional: true,
+      default: false,
+    },
+    startTime: {
+      type: "string",
+      label: "Start Time",
+      description: "Starting date filter for results (format: `YYYY-MM-DDTHH:mm:ss.sssZ`)",
+      optional: true,
+    },
+    endTime: {
+      type: "string",
+      label: "End Time",
+      description: "Ending date filter for results (format: `YYYY-MM-DDTHH:mm:ss.sssZ`)",
+      optional: true,
+    },
+    targetAccountId: {
+      type: "integer",
+      label: "Target Account ID",
+      description: "AccountId fetching the trade history, must be a paired account with main user",
+      optional: true,
+    },
+    targetAccountIds: {
+      type: "string",
+      label: "Target Account IDs",
+      description: "AccountIds fetching the trade history, must be a paired account with main user. Can be wildcard `*` to get all accounts linked to the authenticated user",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.bitmex.getTradeHistory({
+      filter: this.filter,
+      symbol: this.symbol,
+      columns: this.columns,
+      count: this.count,
+      start: this.start,
+      reverse: this.reverse,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      targetAccountId: this.targetAccountId,
+      targetAccountIds: this.targetAccountIds,
+    });
+
+    const count = Array.isArray(response)
+      ? response.length
+      : 0;
+    $.export("$summary", `Successfully retrieved ${count} trade${count === 1
+      ? ""
+      : "s"}`);
+    return response;
+  },
+};

package/bitmex.app.mjs

@@ -1,11 +1,248 @@
+import crypto from "crypto";
+import axios from "axios";
+
 export default {
   type: "app",
   app: "bitmex",
-  propDefinitions: {},
+  propDefinitions: {
+    currency: {
+      type: "string",
+      label: "Currency",
+      description: "Any currency. For all currencies specify \"all\"",
+      async options() {
+        const assets = await this.getAssetsConfig();
+        const currencies = assets.map((asset) => ({
+          label: asset.currency || asset.asset,
+          value: asset.currency || asset.asset,
+        }));
+        return [
+          {
+            label: "All currencies",
+            value: "all",
+          },
+          ...currencies,
+        ];
+      },
+    },
+    symbol: {
+      type: "string",
+      label: "Symbol",
+      description: "Instrument symbol. Send a bare series (e.g. `XBT`) to get data for the nearest expiring contract in that series. You can also send a timeframe, e.g. `XBT:quarterly`. Timeframes are `nearest`, `daily`, `weekly`, `monthly`, `quarterly`, `biquarterly`, and `perpetual`. Symbols are case-insensitive.",
+      async options() {
+        const instruments = await this.getActiveAndIndices();
+        return instruments.map((instrument) => ({
+          label: `${instrument.symbol}${instrument.typ
+            ? ` (${instrument.typ})`
+            : ""}`,
+          value: instrument.symbol,
+        }));
+      },
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _apiUrl() {
+      return this.$auth.api_url || "https://www.bitmex.com";
+    },
+    _generateSignature(apiSecret, verb, path, expires, data) {
+      const message = verb + path + expires + data;
+      return crypto
+        .createHmac("sha256", apiSecret)
+        .update(message)
+        .digest("hex");
+    },
+    async _makeRequest({
+      method = "GET", path, params, data,
+    } = {}) {
+      const verb = method.toUpperCase();
+      const expires = Math.floor(Date.now() / 1000) + 60; // UNIX timestamp in seconds
+
+      // Build query string if params exist
+      let fullPath = path;
+      let queryString = "";
+      if (params && Object.keys(params).length > 0) {
+        const searchParams = new URLSearchParams();
+        Object.entries(params).forEach(([
+          key,
+          value,
+        ]) => {
+          if (value != null) {
+            searchParams.append(key, value);
+          }
+        });
+        queryString = searchParams.toString();
+        if (queryString) {
+          fullPath += `?${queryString}`;
+        }
+      }
+
+      // Handle request body data
+      let dataString = "";
+      let requestData = null;
+      if (data && verb !== "GET") {
+        // For POST/PUT requests, convert data to JSON string
+        dataString = JSON.stringify(data);
+        requestData = data;
+      }
+
+      const signature = this._generateSignature(
+        this.$auth.api_secret,
+        verb,
+        fullPath,
+        expires,
+        dataString,
+      );
+
+      const headers = {
+        "api-key": this.$auth.api_key,
+        "api-expires": expires,
+        "api-signature": signature,
+      };
+
+      const config = {
+        method: verb,
+        url: `${this._apiUrl()}${fullPath}`,
+        headers,
+      };
+
+      if (requestData && verb !== "GET") {
+        config.data = requestData;
+        headers["Content-Type"] = "application/json";
+      }
+
+      const response = await axios(config);
+      return response.data;
+    },
+    async getAssetsConfig() {
+      return this._makeRequest({
+        method: "GET",
+        path: "/api/v1/wallet/assets",
+      });
+    },
+    async getActiveAndIndices() {
+      return this._makeRequest({
+        method: "GET",
+        path: "/api/v1/instrument/activeAndIndices",
+      });
+    },
+    async getUserWallet({ currency } = {}) {
+      return this._makeRequest({
+        method: "GET",
+        path: "/api/v1/user/wallet",
+        params: {
+          currency,
+        },
+      });
+    },
+    async getTradeHistory({
+      filter, symbol, columns, count, start, reverse, startTime, endTime, targetAccountId,
+      targetAccountIds,
+    } = {}) {
+      const params = {};
+      if (filter != null) {
+        params.filter = typeof filter === "string"
+          ? filter
+          : JSON.stringify(filter);
+      }
+      if (symbol != null) params.symbol = symbol;
+      if (columns != null) {
+        params.columns = typeof columns === "string"
+          ? columns
+          : JSON.stringify(columns);
+      }
+      if (count != null) params.count = count.toString();
+      if (start != null) params.start = start.toString();
+      if (reverse != null) params.reverse = reverse;
+      if (startTime != null) params.startTime = startTime;
+      if (endTime != null) params.endTime = endTime;
+      if (targetAccountId != null) params.targetAccountId = targetAccountId.toString();
+      if (targetAccountIds != null) {
+        params.targetAccountIds = typeof targetAccountIds === "string"
+          ? targetAccountIds
+          : JSON.stringify(targetAccountIds);
+      }
+
+      return this._makeRequest({
+        method: "GET",
+        path: "/api/v1/execution/tradeHistory",
+        params,
+      });
+    },
+    async createOrder({
+      symbol, strategy, side, orderQty, price, displayQty, stopPx, clOrdID, clOrdLinkID,
+      pegOffsetValue, pegPriceType, ordType, timeInForce, execInst, contingencyType, text,
+    } = {}) {
+      const data = {};
+      if (symbol != null) data.symbol = symbol;
+      if (strategy != null) data.strategy = strategy;
+      if (side != null) data.side = side;
+      if (orderQty != null) data.orderQty = orderQty.toString();
+      if (price != null) data.price = price.toString();
+      if (displayQty != null) data.displayQty = displayQty.toString();
+      if (stopPx != null) data.stopPx = stopPx.toString();
+      if (clOrdID != null) data.clOrdID = clOrdID;
+      if (clOrdLinkID != null) data.clOrdLinkID = clOrdLinkID;
+      if (pegOffsetValue != null) data.pegOffsetValue = pegOffsetValue.toString();
+      if (pegPriceType != null) data.pegPriceType = pegPriceType;
+      if (ordType != null) data.ordType = ordType;
+      if (timeInForce != null) data.timeInForce = timeInForce;
+      if (execInst != null) data.execInst = execInst;
+      if (contingencyType != null) data.contingencyType = contingencyType;
+      if (text != null) data.text = text;
+
+      return this._makeRequest({
+        method: "POST",
+        path: "/api/v1/order",
+        data,
+      });
+    },
+    async getOrders({
+      symbol, filter, columns, count, start, reverse, startTime, endTime,
+    } = {}) {
+      const params = {};
+      if (symbol != null) params.symbol = symbol;
+      if (filter != null) {
+        params.filter = typeof filter === "string"
+          ? filter
+          : JSON.stringify(filter);
+      }
+      if (columns != null) {
+        params.columns = typeof columns === "string"
+          ? columns
+          : JSON.stringify(columns);
+      }
+      if (count != null) params.count = count.toString();
+      if (start != null) params.start = start.toString();
+      if (reverse != null) params.reverse = reverse;
+      if (startTime != null) params.startTime = startTime;
+      if (endTime != null) params.endTime = endTime;
+
+      return this._makeRequest({
+        method: "GET",
+        path: "/api/v1/order",
+        params,
+      });
+    },
+    async getPositions({
+      filter, columns, count,
+    } = {}) {
+      const params = {};
+      if (filter != null) {
+        params.filter = typeof filter === "string"
+          ? filter
+          : JSON.stringify(filter);
+      }
+      if (columns != null) {
+        params.columns = typeof columns === "string"
+          ? columns
+          : JSON.stringify(columns);
+      }
+      if (count != null) params.count = count.toString();
+
+      return this._makeRequest({
+        method: "GET",
+        path: "/api/v1/position",
+        params,
+      });
     },
   },
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/bitmex",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream BitMEX Components",
   "main": "bitmex.app.mjs",
   "keywords": [
@@ -11,5 +11,9 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.1.1",
+    "axios": "^1.6.0"
   }
 }

package/sources/common/common-polling.mjs

@@ -0,0 +1,23 @@
+import bitmex from "../../bitmex.app.mjs";
+import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
+
+export default {
+  props: {
+    bitmex,
+    db: "$.service.db",
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+  },
+  methods: {
+    _getLastTimestamp() {
+      return this.db.get("lastTimestamp");
+    },
+    _setLastTimestamp(timestamp) {
+      this.db.set("lastTimestamp", timestamp);
+    },
+  },
+};

package/sources/new-executed-trade/new-executed-trade.mjs

@@ -0,0 +1,127 @@
+import common from "../common/common-polling.mjs";
+
+export default {
+  ...common,
+  key: "bitmex-new-executed-trade",
+  name: "New Executed Trade",
+  description: "Emit new event when a balance‑affecting execution (trade fill, settlement, realized PnL) occurs in your BitMEX account. [See the documentation](https://www.bitmex.com/api/explorer/#!/Execution/Execution_getTradeHistory)",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    targetAccountId: {
+      type: "integer",
+      label: "Target Account ID",
+      description: "AccountId fetching the trade history, must be a paired account with main user",
+    },
+    symbol: {
+      propDefinition: [
+        common.props.bitmex,
+        "symbol",
+      ],
+      optional: true,
+    },
+  },
+  methods: {
+    ...common.methods,
+    _getEmittedTradeIds() {
+      return new Set(this.db.get("emittedTradeIds") || []);
+    },
+    _setEmittedTradeIds(tradeIds) {
+      this.db.set("emittedTradeIds", Array.from(tradeIds));
+    },
+  },
+  hooks: {
+    async deploy() {
+      const trades = await this.bitmex.getTradeHistory({
+        targetAccountId: this.targetAccountId,
+        symbol: this.symbol,
+        count: 25,
+        reverse: true,
+      });
+
+      const emittedTradeIds = new Set();
+      for (const trade of trades.slice(0, 10)) {
+        if (trade.execID) {
+          emittedTradeIds.add(trade.execID);
+          this.$emit(trade, {
+            id: trade.execID,
+            summary: `Executed trade: ${trade.symbol} ${trade.side || ""} ${trade.lastQty || 0} @ ${trade.lastPx || 0}`,
+            ts: trade.timestamp
+              ? new Date(trade.timestamp).getTime()
+              : Date.now(),
+          });
+        }
+      }
+      this._setEmittedTradeIds(emittedTradeIds);
+      if (trades.length > 0 && trades[0].timestamp) {
+        this._setLastTimestamp(new Date(trades[0].timestamp).getTime());
+      }
+    },
+  },
+  async run() {
+    const lastTimestamp = this._getLastTimestamp();
+    const emittedTradeIds = this._getEmittedTradeIds();
+    const now = Date.now();
+
+    const trades = await this.bitmex.getTradeHistory({
+      targetAccountId: this.targetAccountId,
+      symbol: this.symbol,
+      count: 100,
+      reverse: true,
+    });
+
+    const newTrades = [];
+    for (const trade of trades) {
+      if (!trade.execID || emittedTradeIds.has(trade.execID)) {
+        continue;
+      }
+
+      const tradeTimestamp = trade.timestamp
+        ? new Date(trade.timestamp).getTime()
+        : now;
+      if (!lastTimestamp || tradeTimestamp > lastTimestamp) {
+        newTrades.push(trade);
+        emittedTradeIds.add(trade.execID);
+      }
+    }
+
+    // Sort by timestamp ascending
+    newTrades.sort((a, b) => {
+      const tsA = a.timestamp
+        ? new Date(a.timestamp).getTime()
+        : 0;
+      const tsB = b.timestamp
+        ? new Date(b.timestamp).getTime()
+        : 0;
+      return tsA - tsB;
+    });
+
+    for (const trade of newTrades) {
+      this.$emit(trade, {
+        id: trade.execID,
+        summary: `Executed trade: ${trade.symbol} ${trade.side || ""} ${trade.lastQty || 0} @ ${trade.lastPx || 0}`,
+        ts: trade.timestamp
+          ? new Date(trade.timestamp).getTime()
+          : Date.now(),
+      });
+    }
+
+    if (newTrades.length > 0) {
+      const latestTimestamp = newTrades[newTrades.length - 1].timestamp
+        ? new Date(newTrades[newTrades.length - 1].timestamp).getTime()
+        : now;
+      this._setLastTimestamp(latestTimestamp);
+    }
+
+    // Keep only recent trade IDs (last 1000)
+    const tradeIdsArray = Array.from(emittedTradeIds);
+    if (tradeIdsArray.length > 1000) {
+      this._setEmittedTradeIds(new Set(tradeIdsArray.slice(-1000)));
+    } else {
+      this._setEmittedTradeIds(emittedTradeIds);
+    }
+  },
+};
+

package/sources/new-order/new-order.mjs

@@ -0,0 +1,119 @@
+import common from "../common/common-polling.mjs";
+
+export default {
+  ...common,
+  key: "bitmex-new-order",
+  name: "New Order",
+  description: "Emit new event when a new order is placed on your BitMEX account. [See the documentation](https://www.bitmex.com/api/explorer/#!/Order/Order_getOrders)",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    symbol: {
+      propDefinition: [
+        common.props.bitmex,
+        "symbol",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    _getEmittedOrderIds() {
+      return new Set(this.db.get("emittedOrderIds") || []);
+    },
+    _setEmittedOrderIds(orderIds) {
+      this.db.set("emittedOrderIds", Array.from(orderIds));
+    },
+  },
+  hooks: {
+    async deploy() {
+      const orders = await this.bitmex.getOrders({
+        symbol: this.symbol,
+        count: 25,
+        reverse: true,
+      });
+
+      const emittedOrderIds = new Set();
+      for (const order of orders.slice(0, 10)) {
+        if (order.orderID) {
+          emittedOrderIds.add(order.orderID);
+          this.$emit(order, {
+            id: order.orderID,
+            summary: `New order: ${order.symbol} ${order.side} ${order.orderQty || 0}`,
+            ts: order.timestamp
+              ? new Date(order.timestamp).getTime()
+              : Date.now(),
+          });
+        }
+      }
+      this._setEmittedOrderIds(emittedOrderIds);
+      if (orders.length > 0 && orders[0].timestamp) {
+        this._setLastTimestamp(new Date(orders[0].timestamp).getTime());
+      }
+    },
+  },
+  async run() {
+    const lastTimestamp = this._getLastTimestamp();
+    const emittedOrderIds = this._getEmittedOrderIds();
+    const now = Date.now();
+
+    const orders = await this.bitmex.getOrders({
+      symbol: this.symbol,
+      count: 100,
+      reverse: true,
+    });
+
+    const newOrders = [];
+    for (const order of orders) {
+      if (!order.orderID || emittedOrderIds.has(order.orderID)) {
+        continue;
+      }
+
+      const orderTimestamp = order.timestamp
+        ? new Date(order.timestamp).getTime()
+        : now;
+      if (!lastTimestamp || orderTimestamp > lastTimestamp) {
+        newOrders.push(order);
+        emittedOrderIds.add(order.orderID);
+      }
+    }
+
+    // Sort by timestamp ascending
+    newOrders.sort((a, b) => {
+      const tsA = a.timestamp
+        ? new Date(a.timestamp).getTime()
+        : 0;
+      const tsB = b.timestamp
+        ? new Date(b.timestamp).getTime()
+        : 0;
+      return tsA - tsB;
+    });
+
+    for (const order of newOrders) {
+      this.$emit(order, {
+        id: order.orderID,
+        summary: `New order: ${order.symbol} ${order.side} ${order.orderQty || 0}`,
+        ts: order.timestamp
+          ? new Date(order.timestamp).getTime()
+          : Date.now(),
+      });
+    }
+
+    if (newOrders.length > 0) {
+      const latestTimestamp = newOrders[newOrders.length - 1].timestamp
+        ? new Date(newOrders[newOrders.length - 1].timestamp).getTime()
+        : now;
+      this._setLastTimestamp(latestTimestamp);
+    }
+
+    // Keep only recent order IDs (last 1000)
+    const orderIdsArray = Array.from(emittedOrderIds);
+    if (orderIdsArray.length > 1000) {
+      this._setEmittedOrderIds(new Set(orderIdsArray.slice(-1000)));
+    } else {
+      this._setEmittedOrderIds(emittedOrderIds);
+    }
+  },
+};
+