@polymarbot/shared 0.3.8 → 0.4.0

package/execution-queue/manager.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/execution-queue/manager.ts
+var manager_exports = {};
+__export(manager_exports, {
+  QueueManager: () => QueueManager
+});
+module.exports = __toCommonJS(manager_exports);
+
+// src/utils/execution-queue/queue.ts
+var ExecutionQueue = class {
+  queue = [];
+  processing = false;
+  /**
+   * Enqueue an async function to be executed
+   * @param fn - Async function to execute
+   * @returns Promise that resolves with the function's result
+   */
+  async enqueue(fn) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ fn, resolve, reject });
+      this.processQueue();
+    });
+  }
+  /**
+   * Process the queue sequentially
+   */
+  async processQueue() {
+    if (this.processing) return;
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const task = this.queue.shift();
+      try {
+        const result = await task.fn();
+        task.resolve(result);
+      } catch (error) {
+        task.reject(error);
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * Get current queue length
+   */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+   * Check if queue is currently processing
+   */
+  get isProcessing() {
+    return this.processing;
+  }
+};
+
+// src/utils/execution-queue/manager.ts
+var queues = /* @__PURE__ */ new Map();
+function cleanupInactiveQueues() {
+  for (const [id, queue] of queues.entries()) {
+    if (queue.length === 0 && !queue.isProcessing) {
+      queues.delete(id);
+    }
+  }
+}
+function getOrCreateQueue(id) {
+  cleanupInactiveQueues();
+  if (!queues.has(id)) {
+    queues.set(id, new ExecutionQueue());
+  }
+  return queues.get(id);
+}
+var QueueManager = {
+  /**
+   * Execute an operation in the queue identified by ID
+   * @param id - Unique identifier for the queue
+   * @param operation - Async operation to execute
+   * @returns Promise that resolves with the operation result
+   */
+  async execute(id, operation) {
+    const queue = getOrCreateQueue(id);
+    return queue.enqueue(operation);
+  },
+  /**
+   * Get current active queue count (for monitoring/debugging)
+   */
+  getActiveQueueCount() {
+    return queues.size;
+  },
+  /**
+   * Clear a specific queue by ID
+   * @param id - Queue ID to clear
+   */
+  clear(id) {
+    queues.delete(id);
+  },
+  /**
+   * Clear all queues (mainly for testing)
+   */
+  clearAll() {
+    queues.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueueManager
+});

package/execution-queue/manager.d.cts

@@ -0,0 +1,12 @@
+declare const QueueManager: {
+    
+    execute<T>(id: string, operation: () => Promise<T>): Promise<T>;
+    
+    getActiveQueueCount(): number;
+    
+    clear(id: string): void;
+    
+    clearAll(): void;
+};
+
+export { QueueManager };

package/execution-queue/manager.d.ts

@@ -0,0 +1,12 @@
+declare const QueueManager: {
+    
+    execute<T>(id: string, operation: () => Promise<T>): Promise<T>;
+    
+    getActiveQueueCount(): number;
+    
+    clear(id: string): void;
+    
+    clearAll(): void;
+};
+
+export { QueueManager };

package/execution-queue/manager.js

@@ -0,0 +1,98 @@
+import "../chunk-JSBRDJBE.js";
+
+// src/utils/execution-queue/queue.ts
+var ExecutionQueue = class {
+  queue = [];
+  processing = false;
+  /**
+   * Enqueue an async function to be executed
+   * @param fn - Async function to execute
+   * @returns Promise that resolves with the function's result
+   */
+  async enqueue(fn) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ fn, resolve, reject });
+      this.processQueue();
+    });
+  }
+  /**
+   * Process the queue sequentially
+   */
+  async processQueue() {
+    if (this.processing) return;
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const task = this.queue.shift();
+      try {
+        const result = await task.fn();
+        task.resolve(result);
+      } catch (error) {
+        task.reject(error);
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * Get current queue length
+   */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+   * Check if queue is currently processing
+   */
+  get isProcessing() {
+    return this.processing;
+  }
+};
+
+// src/utils/execution-queue/manager.ts
+var queues = /* @__PURE__ */ new Map();
+function cleanupInactiveQueues() {
+  for (const [id, queue] of queues.entries()) {
+    if (queue.length === 0 && !queue.isProcessing) {
+      queues.delete(id);
+    }
+  }
+}
+function getOrCreateQueue(id) {
+  cleanupInactiveQueues();
+  if (!queues.has(id)) {
+    queues.set(id, new ExecutionQueue());
+  }
+  return queues.get(id);
+}
+var QueueManager = {
+  /**
+   * Execute an operation in the queue identified by ID
+   * @param id - Unique identifier for the queue
+   * @param operation - Async operation to execute
+   * @returns Promise that resolves with the operation result
+   */
+  async execute(id, operation) {
+    const queue = getOrCreateQueue(id);
+    return queue.enqueue(operation);
+  },
+  /**
+   * Get current active queue count (for monitoring/debugging)
+   */
+  getActiveQueueCount() {
+    return queues.size;
+  },
+  /**
+   * Clear a specific queue by ID
+   * @param id - Queue ID to clear
+   */
+  clear(id) {
+    queues.delete(id);
+  },
+  /**
+   * Clear all queues (mainly for testing)
+   */
+  clearAll() {
+    queues.clear();
+  }
+};
+export {
+  QueueManager
+};

package/index.cjs

@@ -1,6 +1,7 @@
 module.exports = {
   ...require('./basic.cjs'),
   ...require('./crypto.cjs'),
+  ...require('./execution-queue/manager.cjs'),
   ...require('./hash.cjs'),
   ...require('./loadEnv.cjs'),
   ...require('./markets/types.cjs'),

package/index.d.cts

@@ -1,5 +1,6 @@
 export * from './basic.js'
 export * from './crypto.js'
+export * from './execution-queue/manager.js'
 export * from './hash.js'
 export * from './loadEnv.js'
 export * from './markets/types.js'

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './basic.js'
 export * from './crypto.js'
+export * from './execution-queue/manager.js'
 export * from './hash.js'
 export * from './loadEnv.js'
 export * from './markets/types.js'

package/index.js

@@ -1,5 +1,6 @@
 export * from './basic.js'
 export * from './crypto.js'
+export * from './execution-queue/manager.js'
 export * from './hash.js'
 export * from './loadEnv.js'
 export * from './markets/types.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymarbot/shared",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -36,6 +36,16 @@
         "default": "./crypto.cjs"
       }
     },
+    "./execution-queue/manager": {
+      "import": {
+        "types": "./execution-queue/manager.d.ts",
+        "default": "./execution-queue/manager.js"
+      },
+      "require": {
+        "types": "./execution-queue/manager.d.cts",
+        "default": "./execution-queue/manager.cjs"
+      }
+    },
     "./hash": {
       "import": {
         "types": "./hash.d.ts",

package/trade-strategy/normalize.cjs

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var normalize_exports = {};
 __export(normalize_exports, {
   hasTradeStepsBuy: () => hasTradeStepsBuy,
-  normalizeStrategy: () => normalizeStrategy
+  normalizeStrategy: () => normalizeStrategy,
+  stringifyTradeStep: () => stringifyTradeStep,
+  stringifyTradeSteps: () => stringifyTradeSteps
 });
 module.exports = __toCommonJS(normalize_exports);
 function normalizeTradeStepBuy(step, options) {
@@ -141,8 +143,54 @@ function normalizeStrategy(config, options = {}) {
 function hasTradeStepsBuy(config) {
   return config.some((step) => step.side === "BUY" /* BUY */);
 }
+function sortObjectKeys(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (item !== null && typeof item === "object") {
+        return sortObjectKeys(item);
+      }
+      return item;
+    });
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const sortedObj = {};
+  for (const key of sortedKeys) {
+    const val = obj[key];
+    if (val !== null && typeof val === "object") {
+      sortedObj[key] = sortObjectKeys(val);
+    } else {
+      sortedObj[key] = val;
+    }
+  }
+  return sortedObj;
+}
+function stringifyTradeStep(step) {
+  return JSON.stringify(sortObjectKeys(step));
+}
+function stringifyTradeSteps(config) {
+  const processedSteps = config.map(
+    (step) => sortObjectKeys(step)
+  );
+  const sortedSteps = [...processedSteps].sort((a, b) => {
+    const sideA = a.side;
+    const sideB = b.side;
+    if (sideA === "BUY" /* BUY */ && sideB === "SELL" /* SELL */) {
+      return -1;
+    }
+    if (sideA === "SELL" /* SELL */ && sideB === "BUY" /* BUY */) {
+      return 1;
+    }
+    return JSON.stringify(a).localeCompare(JSON.stringify(b));
+  });
+  return JSON.stringify(sortedSteps);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   hasTradeStepsBuy,
-  normalizeStrategy
+  normalizeStrategy,
+  stringifyTradeStep,
+  stringifyTradeSteps
 });

package/trade-strategy/normalize.d.cts

@@ -1,4 +1,4 @@
-import { StrategyConfig } from './types.cjs';
+import { StrategyConfig, TradeStep } from './types.cjs';
 import '@polymarket/clob-client';
 import '../markets/types.cjs';
 
@@ -13,4 +13,8 @@ declare function normalizeStrategy(config: StrategyConfig, options?: NormalizeSt
 
 declare function hasTradeStepsBuy(config: StrategyConfig): boolean;
 
-export { type NormalizeStrategyOptions, hasTradeStepsBuy, normalizeStrategy };
+declare function stringifyTradeStep(step: TradeStep): string;
+
+declare function stringifyTradeSteps(config: StrategyConfig): string;
+
+export { type NormalizeStrategyOptions, hasTradeStepsBuy, normalizeStrategy, stringifyTradeStep, stringifyTradeSteps };

package/trade-strategy/normalize.d.ts

@@ -1,4 +1,4 @@
-import { StrategyConfig } from './types.js';
+import { StrategyConfig, TradeStep } from './types.js';
 import '@polymarket/clob-client';
 import '../markets/types.js';
 
@@ -13,4 +13,8 @@ declare function normalizeStrategy(config: StrategyConfig, options?: NormalizeSt
 
 declare function hasTradeStepsBuy(config: StrategyConfig): boolean;
 
-export { type NormalizeStrategyOptions, hasTradeStepsBuy, normalizeStrategy };
+declare function stringifyTradeStep(step: TradeStep): string;
+
+declare function stringifyTradeSteps(config: StrategyConfig): string;
+
+export { type NormalizeStrategyOptions, hasTradeStepsBuy, normalizeStrategy, stringifyTradeStep, stringifyTradeSteps };

package/trade-strategy/normalize.js

@@ -119,7 +119,53 @@ function normalizeStrategy(config, options = {}) {
 function hasTradeStepsBuy(config) {
   return config.some((step) => step.side === "BUY" /* BUY */);
 }
+function sortObjectKeys(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (item !== null && typeof item === "object") {
+        return sortObjectKeys(item);
+      }
+      return item;
+    });
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const sortedObj = {};
+  for (const key of sortedKeys) {
+    const val = obj[key];
+    if (val !== null && typeof val === "object") {
+      sortedObj[key] = sortObjectKeys(val);
+    } else {
+      sortedObj[key] = val;
+    }
+  }
+  return sortedObj;
+}
+function stringifyTradeStep(step) {
+  return JSON.stringify(sortObjectKeys(step));
+}
+function stringifyTradeSteps(config) {
+  const processedSteps = config.map(
+    (step) => sortObjectKeys(step)
+  );
+  const sortedSteps = [...processedSteps].sort((a, b) => {
+    const sideA = a.side;
+    const sideB = b.side;
+    if (sideA === "BUY" /* BUY */ && sideB === "SELL" /* SELL */) {
+      return -1;
+    }
+    if (sideA === "SELL" /* SELL */ && sideB === "BUY" /* BUY */) {
+      return 1;
+    }
+    return JSON.stringify(a).localeCompare(JSON.stringify(b));
+  });
+  return JSON.stringify(sortedSteps);
+}
 export {
   hasTradeStepsBuy,
-  normalizeStrategy
+  normalizeStrategy,
+  stringifyTradeStep,
+  stringifyTradeSteps
 };