dexbot 1.4.16 → 1.4.18

package/claw/modules/bitshares_client.ts

@@ -4,8 +4,8 @@
 import { TIMING, NODE_MANAGEMENT } from '../../modules/constants.js';
 import { sleep } from '../../modules/order/utils/system.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
-import * as native from '../../modules/bitshares-native/index.js';
-import { createSigningClient } from '../../modules/bitshares-native/index.js';
+import { readGeneralSettings } from '../../modules/general_settings.js';
+import { createChainClient, createSigningClient, createSubscriptionManager } from '../../modules/bitshares-native/index.js';
 const DEFAULT_TIMEOUT_MS = TIMING.CONNECTION_TIMEOUT_MS;
 const DEFAULT_CHECK_INTERVAL_MS = TIMING.CHECK_INTERVAL_MS;
 
@@ -13,13 +13,28 @@ let connected = false;
 let suppressConnectionLog = false;
 let _nativeClient: any = null;
 let _connectPromise: any = null;
+let _subscriptionManager: any = null;
 
-_nativeClient = native.createChainClient({
+_nativeClient = createChainClient({
     onStatusChange: handleConnectionStatus,
     rpcTimeoutMs: TIMING.CONNECTION_TIMEOUT_MS,
     connectTimeoutMs: TIMING.CONNECTION_TIMEOUT_MS,
 });
-_nativeClient.setNodes(NODE_MANAGEMENT.DEFAULT_NODES);
+_nativeClient.setNodes(resolveConfiguredNodes());
+_subscriptionManager = createSubscriptionManager(_nativeClient);
+_nativeClient.onReconnect = async () => {
+    if (_subscriptionManager && typeof _subscriptionManager.onReconnect === 'function') {
+        await _subscriptionManager.onReconnect();
+    }
+};
+
+function resolveConfiguredNodes(): string[] {
+    const settings = readGeneralSettings({ fallback: null });
+    const configuredNodes = Array.isArray(settings?.NODES?.list)
+        ? settings.NODES.list.filter((node: any) => typeof node === 'string' && node.trim())
+        : [];
+    return configuredNodes.length > 0 ? configuredNodes : NODE_MANAGEMENT.DEFAULT_NODES;
+}
 
 function handleConnectionStatus(status: any) {
     const effectiveStatus = status === 'connected' ? 'open' : status;
@@ -58,6 +73,7 @@ async function ensureConnected() {
 
 async function waitForConnected(timeoutMs = DEFAULT_TIMEOUT_MS) {
     const start = Date.now();
+    let attemptDelayMs = DEFAULT_CHECK_INTERVAL_MS;
 
     while (!connected) {
         if (!_connectPromise && _nativeClient.getStatus() !== 'connecting') {
@@ -68,7 +84,10 @@ async function waitForConnected(timeoutMs = DEFAULT_TIMEOUT_MS) {
         if (Date.now() - start > timeoutMs) {
             throw new Error(`Timed out waiting for BitShares connection after ${timeoutMs}ms`);
         }
-        await sleep(DEFAULT_CHECK_INTERVAL_MS);
+        // Exponential backoff between retry sweeps so a fast-failing node list
+        // does not hammer the network in a tight loop.
+        await sleep(attemptDelayMs);
+        attemptDelayMs = Math.min(attemptDelayMs * 2, Math.max(DEFAULT_CHECK_INTERVAL_MS, 15000));
     }
 }
 
@@ -90,8 +109,29 @@ export { createAccountClient, setSuppressConnectionLog, waitForConnected, isConn
 const BitShares = new Proxy(_nativeClient, {
     get(target: any, prop: string) {
         if (prop === 'node') return target.getNodes();
+        if (prop === 'subscribe') {
+            return (eventType: any, callback: any, accountName: any) => {
+                if (eventType === 'account' && _subscriptionManager) {
+                    return _subscriptionManager.subscribe(accountName, callback);
+                }
+                if (target.subscribe) {
+                    return target.subscribe(eventType, callback, accountName);
+                }
+                throw new Error(`Unsupported subscription event type: ${eventType}`);
+            };
+        }
+        if (prop === 'unsubscribe') {
+            return (eventType: any, callback: any, accountName: any) => {
+                if (eventType === 'account' && _subscriptionManager) {
+                    return _subscriptionManager.unsubscribe(accountName, callback);
+                }
+                if (target.unsubscribe) {
+                    return target.unsubscribe(eventType, callback, accountName);
+                }
+                throw new Error(`Unsupported subscription event type: ${eventType}`);
+            };
+        }
         return target[prop];
     }
 });
-export { BitShares }
-
+export { BitShares }

package/claw/modules/chain_actions.ts

@@ -311,8 +311,17 @@ async function listenForFills(accountNameOrId: any, callback: any) {
       }
 
       for (const fn of Array.from(callbacks)) {
+        // The callback may be async. Run it synchronously so sync throws are
+        // caught here, and attach a catch for async rejections so a rejected
+        // handler cannot become an unhandled promise rejection (crash on
+        // Node >= 15).
         try {
-          fn(fills);
+          const result = fn(fills);
+          if (result && typeof result.then === 'function') {
+            result.catch((err: any) => {
+              console.error('listenForFills callback error:', getErrorMessage(err));
+            });
+          }
         } catch (err: any) {
           console.error('listenForFills callback error:', getErrorMessage(err));
         }

package/claw/modules/claw_infra.ts

@@ -150,11 +150,21 @@ function createStateStore(options: StateStoreOptions = {}) {
     return serializeWrite(() => writeUnsafe(clone(defaultValue)));
   }
 
+  // Read goes through the same write queue + file lock so it never observes a
+  // half-written file while a writer is mid-flight.
+  async function read(): Promise<any> {
+    return serializeWrite(async () => {
+      return withFileLock(async () => {
+        return readFromDisk();
+      });
+    });
+  }
+
   return {
     clear,
     filePath,
     patch,
-    read: readFromDisk,
+    read,
     update,
     write
   };
@@ -219,7 +229,7 @@ function createBitsharesClient(options: BitsharesClientOptions = {}) {
  * Create a market adapter with readAccountSnapshot and readMarketSnapshot helpers,
  * delegating to chain_queries for individual data points.
  */
-function createMarketAdapter(options: Record<string, any> = {}) {
+function createMarketAdapter() {
   const readAccountSnapshot = async (accountRef: string) => {
     const [account, balances, openOrders] = await Promise.all([
       chainQueries.getFullAccount(accountRef),
@@ -297,7 +307,7 @@ function createClawInfrastructure(options: ClawInfrastructureOptions = {}) {
     readyFilePath: (options.bitshares && options.bitshares.readyFilePath) || credential.readyFilePath,
     socketPath: (options.bitshares && options.bitshares.socketPath) || credential.socketPath
   });
-  const market = createMarketAdapter(options.market || options);
+  const market = createMarketAdapter();
   const order = createOrderTools();
   const honest = createHonestEcosystemAdapter({
     logger: runtime.logger

package/claw/modules/claw_launcher.ts

@@ -4,15 +4,28 @@ const require = createRequire(import.meta.url);
 
 import { getStorage } from '../../modules/storage/index.js';
 import { path } from '../../modules/path_api.js';
-import { PATHS, getRecalculateTriggerFile } from '../../modules/paths.js';
 import { loadSettingsFile, resolveRawBotEntries, saveSettingsFile, normalizeBotEntries } from '../../modules/bot_settings.js';
 import { normalizeMode, detectMode, setPreferredMode, describeModeChoice } from './launcher_mode_detector.js';
-import { normalizeRoot, resolveRuntimeScript } from './launcher_paths.js';
+import { normalizeRoot, resolveRuntimeScript, normalizeProfileDir } from './launcher_paths.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 'use strict';
 
 const storage = getStorage();
 
+// Catalog documents bot targets as "Omit or 'all'". Normalize the literal
+// string 'all' to null so launcher functions never treat it as a bot name.
+function resolveBotTarget(botName: string | null): string | null {
+  return botName === 'all' ? null : botName;
+}
+
+function getBotsFile(options: Record<string, any> = {}): string {
+  return path.join(normalizeProfileDir(options), 'bots.json');
+}
+
+function getTriggerFile(options: Record<string, any>, botKey: string): string {
+  return path.join(normalizeProfileDir(options), `recalculate.${botKey}.trigger`);
+}
+
 let _chainKeys: any;
 function getChainKeys(): any {
     if (_chainKeys === undefined) {
@@ -66,6 +79,7 @@ function getPM2Module(): any {
  * @returns {Promise<Object>} { started: true, botName, pid, command }
  */
 async function launcherStart(botName: string | null, options: Record<string, any> = {}) {
+  botName = resolveBotTarget(botName);
   const ROOT = normalizeRoot(options);
   const dexbotPath = resolveRuntimeScript(ROOT, 'dexbot.js');
 
@@ -80,6 +94,10 @@ async function launcherStart(botName: string | null, options: Record<string, any
     cwd: ROOT
   });
 
+  child.on('error', (err: any) => {
+    console.error(`[LAUNCHER] Failed to spawn ${dexbotPath}: ${getErrorMessage(err)}`);
+  });
+
   child.unref();
 
   return {
@@ -97,6 +115,7 @@ async function launcherStart(botName: string | null, options: Record<string, any
  * @returns {Promise<Object>} { started: true, botName, pid, command, dryRun: true }
  */
 async function launcherDrystart(botName: string | null, options: Record<string, any> = {}) {
+  botName = resolveBotTarget(botName);
   const ROOT = normalizeRoot(options);
   const dexbotPath = resolveRuntimeScript(ROOT, 'dexbot.js');
 
@@ -111,6 +130,10 @@ async function launcherDrystart(botName: string | null, options: Record<string,
     cwd: ROOT
   });
 
+  child.on('error', (err: any) => {
+    console.error(`[LAUNCHER] Failed to spawn ${dexbotPath}: ${getErrorMessage(err)}`);
+  });
+
   child.unref();
 
   return {
@@ -129,7 +152,8 @@ async function launcherDrystart(botName: string | null, options: Record<string,
  * @returns {Promise<Object>} { reset: true, targets: [...] }
  */
 async function launcherReset(botName: string | null, options: Record<string, any> = {}) {
-  const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+  botName = resolveBotTarget(botName);
+  const PROFILES_BOTS_FILE = getBotsFile(options);
 
   const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
   const entries = normalizeBotEntries(resolveRawBotEntries(config));
@@ -144,7 +168,7 @@ async function launcherReset(botName: string | null, options: Record<string, any
 
   for (const bot of targets) {
     try {
-      const triggerFile = getRecalculateTriggerFile(bot.botKey);
+      const triggerFile = getTriggerFile(options, bot.botKey);
       storage.writeFile(triggerFile, new Date().toISOString());
       triggered.push({
         botName: bot.name,
@@ -168,7 +192,8 @@ async function launcherReset(botName: string | null, options: Record<string, any
  * @returns {Promise<Object>} { disabled: true, targets: [...] } or { disabled: false, reason: '...' }
  */
 async function launcherDisable(botName: string | null, options: Record<string, any> = {}) {
-  const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+  botName = resolveBotTarget(botName);
+  const PROFILES_BOTS_FILE = getBotsFile(options);
 
   const { config, filePath } = loadSettingsFile(PROFILES_BOTS_FILE);
   const entries = resolveRawBotEntries(config);
@@ -220,8 +245,8 @@ async function launcherDisable(botName: string | null, options: Record<string, a
  * @returns {Promise<Object>} { started: true, targets: [{ botName, pm2: true }] }
  */
 async function launcherPm2Start(botName: string | null, options: Record<string, any> = {}) {
-  const ROOT = normalizeRoot(options);
-  const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+  botName = resolveBotTarget(botName);
+  const PROFILES_BOTS_FILE = getBotsFile(options);
 
   // Validate bot configuration first (better error message)
   const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
@@ -403,6 +428,10 @@ async function launcherClawOnly(options: Record<string, any> = {}) {
     cwd: ROOT
   });
 
+  child.on('error', (err: any) => {
+    console.error(`[LAUNCHER] Failed to spawn ${pm2ScriptPath}: ${getErrorMessage(err)}`);
+  });
+
   child.unref();
 
   return {
@@ -421,6 +450,7 @@ async function launcherClawOnly(options: Record<string, any> = {}) {
  * @returns {Promise<Object>}
  */
 async function launcherUnlockStart(botName: string | null, options: Record<string, any> = {}) {
+  botName = resolveBotTarget(botName);
   const ROOT = normalizeRoot(options);
   const unlockPath = resolveRuntimeScript(ROOT, 'unlock.js');
 
@@ -435,6 +465,10 @@ async function launcherUnlockStart(botName: string | null, options: Record<strin
     cwd: ROOT
   });
 
+  child.on('error', (err: any) => {
+    console.error(`[LAUNCHER] Failed to spawn ${unlockPath}: ${getErrorMessage(err)}`);
+  });
+
   child.unref();
 
   return {

package/claw/modules/claw_manifest.ts

@@ -16,7 +16,15 @@ function groupCommandsByRisk(tools: any[]) {
 
 function describeClawBridge(options: Record<string, any> = {}) {
   const tools = getClawToolCatalog();
-  const focusedRuntime = getSupportedClawRuntime(options.runtimeName || options.runtime);
+  // options.runtime may be a string (runtime name) or an object
+  // (e.g. { name: 'openfang', ... } from createClawInfrastructure). Normalize
+  // both so an object never stringifies to "[object Object]".
+  const runtimeName =
+    options.runtimeName ||
+    (typeof options.runtime === 'object' && options.runtime !== null
+      ? options.runtime.name
+      : options.runtime);
+  const focusedRuntime = getSupportedClawRuntime(runtimeName);
 
   return {
     compatibility: {

package/claw/modules/claw_skill_md.ts

@@ -1,15 +1,33 @@
 
 import { getStorage } from '../../modules/storage/index.js';
 import { path } from '../../modules/path_api.js';
+import { PATHS } from '../../modules/paths.js';
 import { getClawToolCatalog } from './claw_catalog.js';
 import { getSupportedClawRuntime } from './claw_runtime_matrix.js';
-import { buildBridgeCommand, buildSkillTomlLines, createTool, normalizeRepoRoot, normalizeProfileRoot } from './skill_utils.js';
+import { buildSkillTomlLines, createTool, normalizeRepoRoot, normalizeProfileRoot, shellQuote } from './skill_utils.js';
 const storage = getStorage();
 
 function normalizeClawRepoRoot(repoRoot: string) {
   return normalizeRepoRoot(repoRoot);
 }
 
+// Generated docs must reference scripts that actually exist. Prefer the built
+// .js (dist layout); fall back to the .ts source run through tsx.
+function resolveScriptInvocation(repoRoot: string, name: string) {
+  const jsPath = path.join(repoRoot, 'scripts', `${name}.js`);
+  if (storage.exists(jsPath)) {
+    return { command: 'node', script: jsPath };
+  }
+  return { command: 'npx tsx', script: path.join(repoRoot, 'scripts', `${name}.ts`) };
+}
+
+function buildBridgeInvocation(repoRoot: string, profileRoot: string, command: string, extraArgs: any[] = []) {
+  const { command: runner, script } = resolveScriptInvocation(repoRoot, 'claw_bridge');
+  return [runner, script, command, '--profile-root', profileRoot, ...extraArgs]
+    .map((part, index) => (index === 0 ? String(part) : shellQuote(part)))
+    .join(' ');
+}
+
 function buildToolSummary(runtimeName: string) {
   const tools = getClawToolCatalog().filter((tool: any) => tool.runtimes.includes(runtimeName));
   const byRisk = tools.reduce((groups: Record<string, any>, tool: any) => {
@@ -29,9 +47,12 @@ function buildToolSummary(runtimeName: string) {
 }
 
 function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string) {
-  const mcpScriptPath = path.join(repoRoot, 'scripts', 'claw_mcp_server.js').replace(/\\/g, '/');
-  const mcpCommand = `node ${mcpScriptPath}`;
-  const mcpArgs = `["${mcpScriptPath}", "--profile-root", "${profileRoot}"]`;
+  const { command, script: mcpScriptPath } = resolveScriptInvocation(repoRoot, 'claw_mcp_server');
+  // command is 'node' or 'npx tsx'; split so the config blocks can set the
+  // executable and args correctly for both the built and source layouts.
+  const runnerParts = command.split(' ');
+  const mcpExec = runnerParts[0];
+  const mcpArgs = `[${[...runnerParts.slice(1), mcpScriptPath, '--profile-root', profileRoot].map((part: any) => JSON.stringify(part)).join(', ')}]`;
 
   switch (runtime.runtime) {
     case 'hermes':
@@ -45,7 +66,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '```yaml',
         'mcp_servers:',
         '  claw:',
-        '    command: "node"',
+        `    command: "${mcpExec}"`,
         `    args: ${mcpArgs}`,
         '```',
         '',
@@ -72,7 +93,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '  "tools": {',
         '    "mcpServers": {',
         '      "claw": {',
-        `        "command": "node",`,
+        `        "command": "${mcpExec}",`,
         `        "args": ${mcpArgs}`,
         '      }',
         '    }',
@@ -100,7 +121,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '        "claw": {',
         '          "enabled": true,',
         '          "type": "stdio",',
-        '          "command": "node",',
+        `          "command": "${mcpExec}",`,
         `          "args": ${mcpArgs}`,
         '        }',
         '      }',
@@ -129,7 +150,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '.claude/skills/bitshares-claw/SKILL.md',
         '```',
         '',
-        'Use the local JSON bridge in `scripts/claw_bridge.js --runtime nanoclaw` when you want the NanoClaw runtime to talk to DEXBot2.',
+        'Use the local JSON bridge in `scripts/claw_bridge --runtime nanoclaw` when you want the NanoClaw runtime to talk to DEXBot2.',
         '',
         `Set \`DEXBOT_PROFILE_ROOT=${profileRoot}\` if you want a default profile root outside tool args.`
       ].join('\n');
@@ -146,7 +167,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '~/.openfang/skills/bitshares-claw/SKILL.md',
         '```',
         '',
-        'Use the local JSON bridge in `scripts/claw_bridge.js --runtime openfang` when you want the OpenFang runtime to talk to DEXBot2.',
+        'Use the local JSON bridge in `scripts/claw_bridge --runtime openfang` when you want the OpenFang runtime to talk to DEXBot2.',
         '',
         `Set \`DEXBOT_PROFILE_ROOT=${profileRoot}\` if you want a default profile root outside tool args.`
       ].join('\n');
@@ -187,7 +208,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         'Start the memU MCP server:',
         '',
         '```bash',
-        `tsx ${path.join(repoRoot, 'scripts', 'memu_mcp_server.ts').replace(/\\/g, '/')} --memu-dir ${path.join(repoRoot, 'data', 'memu').replace(/\\/g, '/')}`,
+        `tsx ${path.join(repoRoot, 'scripts', 'memu_mcp_server.ts').replace(/\\/g, '/')} --memu-dir ${PATHS.CLAW.MEMU_DIR.replace(/\\/g, '/')}`,
         '```',
         '',
         'Or use the npm script:',
@@ -209,7 +230,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '',
         `Use the native ${runtime.nativeIntegration} path for ${runtime.runtime}.`,
         '',
-        `Preferred bridge command: \`${mcpCommand} --profile-root ${profileRoot}\``
+        `Preferred bridge command: \`${command} ${mcpScriptPath} --profile-root ${profileRoot}\``
       ].join('\n');
   }
 }
@@ -237,8 +258,8 @@ function buildRuntimeSkillToml(runtime: any, repoRoot: string, profileRoot: stri
     .map((tool: any) => createTool(
       tool.toolName,
       tool.description,
-      buildBridgeCommand(
-        path.join(repoRoot, 'scripts', 'claw_bridge.js').replace(/\\/g, '/'),
+      buildBridgeInvocation(
+        repoRoot,
         profileRoot,
         tool.command,
         tool.extraArgs

package/claw/modules/credit_runtime_adapter.ts

@@ -37,6 +37,19 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
     };
   }
 
+  // Config fingerprint so debtPolicy / asset / account edits are picked up
+  // instead of being masked by a permanently cached runtime instance.
+  function _botFingerprint(botEntry: Record<string, any>): string {
+    return JSON.stringify({
+      assetA: botEntry.assetA,
+      assetB: botEntry.assetB,
+      botKey: botEntry.botKey,
+      debtPolicy: botEntry.debtPolicy,
+      name: botEntry.name,
+      preferredAccount: botEntry.preferredAccount,
+    });
+  }
+
   async function _resolveBotEntry(botRef: string | null): Promise<Record<string, any> | null> {
     if (!botRef) return null;
     try {
@@ -53,16 +66,22 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
   async function _getRuntime(botRef: string | null): Promise<any> {
     if (!botRef) return null;
     const cacheKey = botRef;
-    let runtime = _runtimes.get(cacheKey);
-    if (runtime) return runtime;
-
     const botEntry = await _resolveBotEntry(botRef);
     if (!botEntry) return null;
-    if (!botEntry.debtPolicy) return null;
+    if (!botEntry.debtPolicy) {
+      // Config now has no debtPolicy; drop any stale cached runtime.
+      _runtimes.delete(cacheKey);
+      return null;
+    }
+
+    const fingerprint = _botFingerprint(botEntry);
+    const cached = _runtimes.get(cacheKey);
+    if (cached && cached._fingerprint === fingerprint) return cached;
 
     const botShim = _buildBotShim(botEntry);
-    runtime = new CreditRuntime(botShim, { stateDir: _stateDir });
+    const runtime = new CreditRuntime(botShim, { stateDir: _stateDir });
     await runtime.loadState();
+    (runtime as any)._fingerprint = fingerprint;
     _runtimes.set(cacheKey, runtime);
     return runtime;
   }

package/claw/modules/decision_loop.ts

@@ -41,6 +41,9 @@ function getTrendAnalyzer() {
  */
 const analyzers = new Map();
 const analyzerConfigs = new Map();
+// Cached premium per market so the same-market reuse path reports the same
+// premium that the fresh path computed instead of a null placeholder.
+const marketPremiums = new Map();
 
 function configChanged(mpaSymbol: string, config: Record<string, any>) {
   const prev = analyzerConfigs.get(mpaSymbol);
@@ -80,6 +83,7 @@ async function evaluate(accountName: string, options: Record<string, any> = {})
       evaluatedAt: new Date().toISOString(),
       positionCount: 0,
       positions: [],
+      summary: buildSummary([]),
     };
   }
 
@@ -98,7 +102,10 @@ async function evaluate(accountName: string, options: Record<string, any> = {})
         const trendInput = await fetchTrendInput(mpa);
         if (trendInput.marketPrice != null && trendInput.feedPrice != null) {
           const analyzer = getOrCreateAnalyzer(mpa, analyzerConfig);
-          const result = analyzer.update(trendInput.marketPrice, trendInput.feedPrice);
+          // KalmanTrendAnalyzer.update accepts a single price series; the feed
+          // price is tracked separately (and surfaced via premium below).
+          const result = analyzer.update(trendInput.marketPrice);
+          marketPremiums.set(mpa, trendInput.premium);
           trendSignal = {
             trend: result.trend,
             confidence: result.confidence,
@@ -116,7 +123,8 @@ async function evaluate(accountName: string, options: Record<string, any> = {})
         trendSignal = {
           trend: snapshot.trend,
           confidence: snapshot.confidence,
-          premium: snapshot.premium?.percent || null,
+          // TrendAnalysis has no premium field; reuse the cached market premium.
+          premium: marketPremiums.get(mpa) ?? null,
         };
       }
     }

package/claw/modules/dexbot_profiles.ts

@@ -9,6 +9,7 @@ import { writeJsonFileAtomic as baseWriteJsonFileAtomic } from '../../modules/bo
 import { acquireFileLock } from '../../market_adapter/utils/file_lock.js';
 import { assertNoDuplicateBotKeys } from '../../modules/bot_settings.js';
 import { clone } from './utils.js';
+import { createBotKey, sanitizeKey } from '../../modules/account_orders.js';
 const storage = getStorage();
 
 import type { BotSettings, ProfileOptions, Logger, ClawProfileBundle } from './types.js';
@@ -601,30 +602,6 @@ function buildBotSettingsView(bot: Record<string, any> | null, bundle: ClawProfi
   };
 }
 
-/**
- * Sanitize an arbitrary value into a lowercase, hyphenated bot-key string.
- */
-function sanitizeKey(source: any) {
-  if (!source) return 'bot';
-  return String(source)
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '') || 'bot';
-}
-
-function createBotKey(bot: any, index: any) {
-  if (bot && bot.name) {
-    return sanitizeKey(bot.name);
-  }
-  const identifier = bot && bot.assetA && bot.assetB
-    ? `${bot.assetA}/${bot.assetB}`
-    : bot && bot.assetAId && bot.assetBId
-      ? `${bot.assetAId}/${bot.assetBId}`
-      : `bot-${index}`;
-  return `${sanitizeKey(identifier)}-${index}`;
-}
-
 /**
  * Extract raw bot entries from a bots.json settings object.
  * Handles both array format ({ bots: [...] }) and single-bot object format.

package/claw/modules/feed_price_source.ts

@@ -11,7 +11,7 @@
 
 import { getAsset, getBackingAsset, getBitassetData, dbCall } from './chain_queries.js';
 import { computeBtsPerMpa } from './mpa_utils.js';
-import { roundTo } from '../../modules/utils/math_utils.js';
+import { roundTo } from '../../modules/order/utils/math.js';
 'use strict';
 
 

package/claw/modules/honest_ecosystem.ts

@@ -24,6 +24,11 @@ const HARDCODED_HONEST_MONEY_BTS_POOL = {
   withdrawalFeePercent: 0
 };
 
+// Live pool reserves are cached briefly so repeated snapshot calls do not
+// hammer the node; failures are never cached so the fallback retries.
+const POOL_RESERVES_CACHE_TTL_MS = 60_000;
+let _poolReservesCache: { poolId: string; ts: number; value: any } | null = null;
+
 
 function isMpa(asset: any) {
   return Boolean(asset && asset.bitasset_data_id);
@@ -34,22 +39,38 @@ function isHonestAsset(asset: any) {
 }
 
 async function fetchLivePoolReserves(poolId: string = HARDCODED_POOL_ID) {
+  if (_poolReservesCache && _poolReservesCache.poolId === poolId &&
+      Date.now() - _poolReservesCache.ts < POOL_RESERVES_CACHE_TTL_MS) {
+    // Clone on read so consumers mutating the returned object cannot poison
+    // the shared cache for the remaining TTL window.
+    return clone(_poolReservesCache.value);
+  }
+
   try {
     const objects = await getObjects([poolId]);
     const pool = objects && objects[0];
     if (!pool || pool.asset_a == null || pool.asset_b == null) return null;
 
-    const [assetAObj, assetBObj] = await Promise.all([
+    const [assetAObj, assetBObj, shareAssetObj] = await Promise.all([
       getAsset(pool.asset_a),
-      getAsset(pool.asset_b)
+      getAsset(pool.asset_b),
+      getAsset(pool.share_asset).catch(() => null),
     ]);
 
+    // Only report pools that actually trade HONEST.MONEY against BTS as the
+    // reference bridge; a relisted/remapped pool must fall back, not leak
+    // mismatched symbols into the context.
+    const poolSymbols = [assetAObj?.symbol, assetBObj?.symbol];
+    if (!poolSymbols.includes(REFERENCE_SYMBOL) || !poolSymbols.includes(CORE_SYMBOL)) {
+      return null;
+    }
+
     const precisionA = assetAObj?.precision ?? 0;
     const precisionB = assetBObj?.precision ?? 0;
     const balanceA = Number(pool.balance_a) || 0;
     const balanceB = Number(pool.balance_b) || 0;
 
-    return {
+    const result = {
       assetA: {
         amount: precisionA > 0 ? balanceA / Math.pow(10, precisionA) : balanceA,
         symbol: assetAObj?.symbol || CORE_SYMBOL
@@ -59,11 +80,14 @@ async function fetchLivePoolReserves(poolId: string = HARDCODED_POOL_ID) {
         symbol: assetBObj?.symbol || REFERENCE_SYMBOL
       },
       id: poolId,
-      poolSymbol: pool.share_asset || HARDCODED_HONEST_MONEY_BTS_POOL.poolSymbol,
+      // share_asset is an asset ID; prefer its human-readable symbol when resolvable.
+      poolSymbol: shareAssetObj?.symbol || pool.share_asset || HARDCODED_HONEST_MONEY_BTS_POOL.poolSymbol,
       takerFeePercent: pool.taker_fee_percent ?? HARDCODED_HONEST_MONEY_BTS_POOL.takerFeePercent,
       withdrawalFeePercent: pool.withdrawal_fee_percent ?? HARDCODED_HONEST_MONEY_BTS_POOL.withdrawalFeePercent,
       source: 'live-liquidity-pool'
     };
+    _poolReservesCache = { poolId, ts: Date.now(), value: result };
+    return result;
   } catch {
     return null;
   }
@@ -168,8 +192,8 @@ async function resolveHonestPairContext(assetA: any, assetB: any, options: Recor
   }
 
   const bridge = await getHonestMoneyBridge();
-  const assetAEntry = bridge.liquidityPool.reserves.find((entry) => entry.symbol === assetASymbol) || null;
-  const assetBEntry = bridge.liquidityPool.reserves.find((entry) => entry.symbol === assetBSymbol) || null;
+  const assetAEntry = bridge.liquidityPool.reserves.find((entry: any) => entry.symbol === assetASymbol) || null;
+  const assetBEntry = bridge.liquidityPool.reserves.find((entry: any) => entry.symbol === assetBSymbol) || null;
 
   return {
     assetA: {
@@ -184,12 +208,12 @@ async function resolveHonestPairContext(assetA: any, assetB: any, options: Recor
     },
     pool: {
       ...bridge.liquidityPool,
-      source: 'hardcoded-liquidity-pool'
+      source: bridge.source,
     },
     priceBPerA: pairPrice,
     reserveA: assetAEntry ? assetAEntry.amount : null,
     reserveB: assetBEntry ? assetBEntry.amount : null,
-    source: 'hardcoded-liquidity-pool'
+    source: bridge.source
   };
 }