dexbot 1.4.12 → 1.4.14

package/claw/modules/dexbot_bridge.ts

@@ -0,0 +1,82 @@
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+import { path } from '../../modules/path_api.js';
+import { getStorage } from '../../modules/storage/index.js';
+import { BUILD_DIR } from '../../modules/constants.js';
+import { PATHS } from '../../modules/paths.js';
+import { Config } from '../../modules/config.js';
+const storage = getStorage();
+
+function candidateExists(candidatePath: string) {
+  if (storage.exists(candidatePath)) {
+    return true;
+  }
+  if (!path.extname(candidatePath) && storage.exists(`${candidatePath}.js`)) {
+    return true;
+  }
+  if (candidatePath.endsWith('.js') && storage.exists(candidatePath.replace(/\.js$/, '.ts'))) {
+    return true;
+  }
+  return false;
+}
+
+function getDexbot2Root() {
+  if (Config.DEXBOT2_ROOT) {
+    return path.resolve(Config.DEXBOT2_ROOT);
+  }
+
+  const repoRoot = PATHS.PROJECT_ROOT;
+  if (
+    candidateExists(path.join(repoRoot, 'modules', 'order', 'index.js')) ||
+    candidateExists(path.join(repoRoot, BUILD_DIR, 'modules', 'order', 'index.js'))
+  ) {
+    return repoRoot;
+  }
+
+  throw new Error('Unable to resolve DEXBot2 root. Set DEXBOT2_ROOT or run from a DEXBot2 checkout.');
+}
+
+function resolveDexbot2Path(relativePath: string) {
+  const root = getDexbot2Root();
+  const normalizedPath = String(relativePath || '');
+  const candidates = [path.join(root, normalizedPath)];
+
+  if (normalizedPath.endsWith('.js')) {
+    candidates.push(path.join(root, normalizedPath.replace(/\.js$/, '.ts')));
+  }
+
+  candidates.push(path.join(root, BUILD_DIR, normalizedPath));
+
+  for (const candidate of candidates) {
+    if (candidateExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[candidates.length - 1];
+}
+
+function requireDexbot2Module(relativePath: string) {
+  return require(resolveDexbot2Path(relativePath));
+}
+
+function loadDexbotOrderSubsystem() {
+  return requireDexbot2Module('modules/order/index.js');
+}
+
+function loadDexbotOrderUtils() {
+  return loadDexbotOrderSubsystem().utils;
+}
+
+function loadDexbotOrderConstants() {
+  return loadDexbotOrderSubsystem().constants;
+}
+
+function loadDexbotOrderSystemUtils() {
+  return requireDexbot2Module('modules/order/utils/system');
+}
+
+export { getDexbot2Root, loadDexbotOrderConstants, loadDexbotOrderSubsystem, loadDexbotOrderSystemUtils, loadDexbotOrderUtils, requireDexbot2Module, resolveDexbot2Path }
+

package/claw/modules/dexbot_credential_client.ts

@@ -0,0 +1,55 @@
+
+import { DEFAULT_READY_FILE, DEFAULT_SOCKET_PATH, DEFAULT_BROADCAST_TIMEOUT_MS, executeOperationsViaCredentialDaemon, isCredentialDaemonReady, waitForCredentialDaemon, BroadcastUncertainError } from '../../modules/dexbot_credential_client.js';
+
+function getSocketPath(options: Record<string, any> = {}) {
+  return options.socketPath || DEFAULT_SOCKET_PATH;
+}
+
+/**
+ * Broadcast a single operation via the credential daemon.
+ *
+ * Delegates to the hardened modules client (execute-operations request type):
+ * - the outer broadcast timeout defaults to CREDENTIAL_BROADCAST_TIMEOUT_MS
+ *   (30s), which covers the daemon's CREDENTIAL_DAEMON_INNER_DEADLINE_MS
+ *   (25s) inner broadcast deadline — the previous 5s request timeout fired
+ *   while the daemon was still mid-broadcast;
+ * - uncertain outcomes (outer socket timeout, BROADCAST_DEADLINE reply) are
+ *   re-thrown as typed BroadcastUncertainError instead of a plain Error, so
+ *   callers can avoid a blind re-run that would duplicate on-chain orders;
+ * - the daemon retries internally only failures that provably never reached
+ *   the chain; an uncertain broadcast is never re-signed.
+ *
+ * The daemon's execute-operations handler evaluates the single-operation array
+ * with the same policy/HMAC context as any other batch, so this delegation
+ * changes no daemon-side semantics.
+ */
+function broadcastOperationViaCredentialDaemon(accountName: any, operation: any, options: Record<string, any> = {}) {
+  if (!accountName) {
+    return Promise.reject(new Error('accountName is required to broadcast operations'));
+  }
+  if (!operation || typeof operation !== 'object') {
+    return Promise.reject(new Error('operation must be an object'));
+  }
+
+  // A broadcast's outer socket timeout MUST leave room for the daemon's inner
+  // deadline (CREDENTIAL_DAEMON_INNER_DEADLINE_MS, 25s) to fire first and
+  // reply a typed BROADCAST_DEADLINE. A caller-supplied timeout below that
+  // window would time out while the daemon is still mid-broadcast — a false
+  // uncertain on every slow broadcast. Clamp up to the default outer window.
+  const callerTimeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Number(options.timeoutMs) : undefined;
+  const broadcastTimeoutMs = callerTimeoutMs !== undefined
+    ? Math.max(callerTimeoutMs, DEFAULT_BROADCAST_TIMEOUT_MS)
+    : undefined;
+
+  return executeOperationsViaCredentialDaemon(accountName, [operation], {
+    socketPath: getSocketPath(options),
+    timeoutMs: broadcastTimeoutMs,
+    sessionId: options.sessionId || null,
+    botHmacSecret: options.botHmacSecret || null,
+    requestType: 'broadcast',
+    batchId: options.batchId || null,
+    ...(options.nodeUrl ? { nodeUrl: options.nodeUrl } : {}),
+  });
+}
+
+export { DEFAULT_READY_FILE, DEFAULT_SOCKET_PATH, DEFAULT_BROADCAST_TIMEOUT_MS, broadcastOperationViaCredentialDaemon, executeOperationsViaCredentialDaemon, isCredentialDaemonReady, waitForCredentialDaemon, BroadcastUncertainError }