dexbot 1.4.20 → 1.4.21

package/claw/runtimes/openclaw-plugin/index.ts

@@ -3,6 +3,8 @@
 import definePluginEntry from 'openclaw/plugin-sdk/plugin-entry';
 import { getClawToolCatalog } from '../../modules/claw_catalog.js';
 import { runClawCommand } from '../../modules/claw_bridge.js';
+import { getErrorMessage } from '../../../modules/utils/errors.js';
+
 function formatResult(result: any) {
   return JSON.stringify(result, null, 2);
 }
@@ -18,16 +20,31 @@ const plugin = definePluginEntry({
         description: `[${tool.risk}] ${tool.description}`,
         parameters: tool.inputSchema,
         async execute(_id: any, params: any) {
-          const result = await runClawCommand(tool.command, { ...params, runtimeName: 'openclaw' });
-          return {
-            content: [
-              {
-                type: "text",
-                text: formatResult(result)
-              }
-            ],
-            structuredContent: result
-          };
+          // Match the MCP servers' convention: tool failures surface as an
+          // isError result instead of a raw rejected promise.
+          try {
+            const result = await runClawCommand(tool.command, { ...params, runtimeName: 'openclaw' });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatResult(result)
+                }
+              ],
+              structuredContent: result
+            };
+          } catch (error: any) {
+            const text = error && error.stack ? error.stack : getErrorMessage(error);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text
+                }
+              ],
+              isError: true
+            };
+          }
         }
       });
     }

package/claw/runtimes/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "bitshares-claw",
   "name": "BitShares Claw",
   "description": "Native BitShares and DEXBot2 tools from the DEXBot2 claw integration",
-  "version": "1.4.20",
+  "version": "1.4.21",
   "skills": [
     "skills"
   ],

package/claw/runtimes/openclaw-plugin/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bitshares-claw-openclaw-plugin",
   "private": true,
-  "version": "1.4.20",
+  "version": "1.4.21",
   "type": "module",
   "main": "index.js"
 }

package/claw/scripts/claw_bridge.ts

@@ -154,5 +154,5 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   });
 }
 
-export { describeScriptRuntimeManifest as describeRuntimeManifest, main }
+export { describeScriptRuntimeManifest as describeRuntimeManifest }
 

package/claw/scripts/claw_mcp_server.ts

@@ -6,7 +6,7 @@
 // console shim has been installed. Static imports here are limited to the
 // lightweight transport helpers (mcp_utils) which never write to stdout.
 
-import { success, failure, runMcpServer, createMessageParser } from '../modules/mcp_utils.js';
+import { createJsonRpcToolsHandler, jsonRpcError, runMcpServer, createMessageParser } from '../modules/mcp_utils.js';
 import { pathToFileURL } from 'node:url';
 
 console.log = () => {};
@@ -59,84 +59,26 @@ async function listMcpTools() {
   }));
 }
 
-async function handleRequest(message: any, defaults: any) {
-  const { id, method, params } = message;
-
-  switch (method) {
-    case 'initialize':
-      return success(id, {
-        // Echo the client's requested protocol version when provided, so a
-        // JSONL-speaking client can negotiate its own version.
-        protocolVersion: params?.protocolVersion || '2024-11-05',
-        capabilities: {
-          tools: {
-            listChanged: false
-          }
-        },
-        serverInfo: {
-          name: 'bitshares-claw',
-          version: '0.1.0'
-        }
-      });
-
-    case 'notifications/initialized':
-      return;
-
-    case 'ping':
-      return success(id, {});
-
-    case 'tools/list':
-      try {
-        return success(id, {
-          tools: await listMcpTools()
-        });
-      } catch (error: any) {
-        return failure(id, -32602, `Failed to load tool catalog: ${error && error.message ? error.message : String(error)}`);
-      }
-
-    case 'tools/call': {
-      try {
-        const { getClawToolByName } = await import('../modules/claw_catalog.js');
-        const tool = getClawToolByName(params?.name);
-        if (!tool) {
-          return failure(id, -32602, `Unknown tool: ${params?.name || '(missing)'}`);
-        }
-
-        const { runClawCommand } = await import('../modules/claw_bridge.js');
-        const result = await runClawCommand(tool.command, {
-          ...defaults,
-          ...(params?.arguments || {})
-        });
-
-        return success(id, {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2)
-            }
-          ],
-          structuredContent: result
-        });
-      } catch (error: any) {
-        return success(id, {
-          content: [
-            {
-              type: 'text',
-              text: error && error.stack ? error.stack : String(error)
-            }
-          ],
-          isError: true
-        });
-      }
-    }
-
-    default:
-      if (id !== undefined) {
-        return failure(id, -32601, `Method not found: ${method}`);
-      }
+async function callTool(params: any, defaults: any) {
+  const { getClawToolByName } = await import('../modules/claw_catalog.js');
+  const tool = getClawToolByName(params?.name);
+  if (!tool) {
+    throw jsonRpcError(-32602, `Unknown tool: ${params?.name || '(missing)'}`);
   }
+
+  const { runClawCommand } = await import('../modules/claw_bridge.js');
+  return runClawCommand(tool.command, {
+    ...defaults,
+    ...(params?.arguments || {})
+  });
 }
 
+const handleRequest = createJsonRpcToolsHandler({
+  serverName: 'bitshares-claw',
+  listTools: listMcpTools,
+  callTool
+});
+
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   runMcpServer(parseArgs, handleRequest).catch((err: unknown) => {
     process.stderr.write(`${err instanceof Error && err.stack ? err.stack : String(err)}\n`);
@@ -144,5 +86,4 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   });
 }
 
-export { createMessageParser, failure, handleRequest, listMcpTools, success }
-
+export { createMessageParser, handleRequest }

package/claw/scripts/honest_assets_report.ts

@@ -1,5 +1,5 @@
-import { getAsset, getBackingAsset, getBitassetData, getCallOrders, getDynamicGlobalProperties, listAssets } from '../modules/chain_queries.js';
-import { getHardcodedHonestMoneyBridge } from '../modules/honest_ecosystem.js';
+import { getAsset, getBackingAsset, getBitassetData, getCallOrders, getDynamicGlobalProperties } from '../modules/chain_queries.js';
+import { getHonestMoneyBridge, isMpa, paginateListAssets } from '../modules/honest_ecosystem.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 
 const DEFAULT_BATCH_SIZE = 100;
@@ -49,67 +49,17 @@ function toPositiveInteger(value: any, fallback: any) {
   return Number.isInteger(value) && value > 0 ? value : fallback;
 }
 
-function isMpa(asset: any) {
-  return Boolean(asset && asset.bitasset_data_id);
-}
-
-function isHonestAsset(asset: any) {
-  return typeof asset?.symbol === 'string' && asset.symbol.startsWith('HONEST.');
-}
-
 async function fetchAllAssets({ batchSize, maxPages, startSymbol }: { batchSize: any; maxPages: any; startSymbol: any }) {
-  const results = [];
-  let lowerBound = startSymbol;
-  let previousLastSymbol = null;
-
-  for (let page = 0; page < maxPages; page += 1) {
-    const batch = await listAssets(lowerBound, batchSize);
-    if (!Array.isArray(batch) || batch.length === 0) {
-      break;
-    }
-
-    let pageItems = batch.filter(Boolean);
-    if (previousLastSymbol && pageItems[0]?.symbol === previousLastSymbol) {
-      pageItems = pageItems.slice(1);
-    }
-
-    if (pageItems.length === 0) {
-      break;
-    }
-
+  const results: any[] = [];
+  await paginateListAssets({ batchSize, maxPages, startSymbol }, (pageItems) => {
     results.push(...pageItems);
-    previousLastSymbol = pageItems[pageItems.length - 1].symbol;
-    lowerBound = previousLastSymbol;
-
-    if (batch.length < batchSize) {
-      break;
-    }
-  }
-
+  });
   return results;
 }
 
 async function fetchAssetsByPrefix({ batchSize, maxPages, prefix, startSymbol }: { batchSize: any; maxPages: any; prefix: any; startSymbol: any }) {
-  const results = [];
-  let lowerBound = startSymbol;
-  let previousLastSymbol = null;
-
-  for (let page = 0; page < maxPages; page += 1) {
-    const batch = await listAssets(lowerBound, batchSize);
-    if (!Array.isArray(batch) || batch.length === 0) {
-      break;
-    }
-
-    let pageItems = batch.filter(Boolean);
-    if (previousLastSymbol && pageItems[0]?.symbol === previousLastSymbol) {
-      pageItems = pageItems.slice(1);
-    }
-
-    if (pageItems.length === 0) {
-      break;
-    }
-
-    const matching = [];
+  const matching: any[] = [];
+  await paginateListAssets({ batchSize, maxPages, startSymbol }, (pageItems) => {
     let crossedPrefixBoundary = false;
 
     for (const item of pageItems) {
@@ -125,18 +75,10 @@ async function fetchAssetsByPrefix({ batchSize, maxPages, prefix, startSymbol }:
       }
     }
 
-    results.push(...matching);
-
-    const lastItem = pageItems[pageItems.length - 1];
-    previousLastSymbol = lastItem?.symbol || previousLastSymbol;
-    lowerBound = previousLastSymbol || lowerBound;
-
-    if (crossedPrefixBoundary || batch.length < batchSize) {
-      break;
-    }
-  }
+    return !crossedPrefixBoundary;
+  });
 
-  return results;
+  return matching;
 }
 
 async function mapWithConcurrency(items: any, concurrency: any, mapper: any) {
@@ -179,16 +121,14 @@ function computeBasePerQuote(priceObject: any, assetMap: any) {
 }
 
 async function getHonestMoneyPerBts(referenceAsset: any, coreAsset: any) {
-  const bridge = getHardcodedHonestMoneyBridge();
-  const coreSide = [bridge.liquidityPool.reserves[0], bridge.liquidityPool.reserves[1]].find((asset) => asset.symbol === coreAsset.symbol);
-  const referenceSide = [bridge.liquidityPool.reserves[0], bridge.liquidityPool.reserves[1]].find((asset) => asset.symbol === referenceAsset.symbol);
-
-  if (!coreSide || !referenceSide) {
-    return null;
-  }
-
-  const latestHonestMoneyPerBts = referenceSide.amount / coreSide.amount;
-  if (!Number.isFinite(latestHonestMoneyPerBts) || latestHonestMoneyPerBts <= 0) {
+  // Prefer the live HONEST.MONEY/BTS pool (60s-cached); the module falls back
+  // to the hardcoded snapshot when the node cannot serve reserves. Reading the
+  // live bridge here keeps this report — whose purpose is refreshing those
+  // hardcoded values — from always printing stale fallback data.
+  const bridge = await getHonestMoneyBridge();
+  const latestHonestMoneyPerBts = bridge?.latestHonestMoneyPerBts ?? null;
+
+  if (latestHonestMoneyPerBts === null || !Number.isFinite(latestHonestMoneyPerBts) || latestHonestMoneyPerBts <= 0) {
     return null;
   }
 
@@ -197,8 +137,7 @@ async function getHonestMoneyPerBts(referenceAsset: any, coreAsset: any) {
       id: bridge.liquidityPool.id,
       poolSymbol: bridge.liquidityPool.poolSymbol,
       reserves: [
-        bridge.liquidityPool.reserves[0],
-        bridge.liquidityPool.reserves[1]
+        ...bridge.liquidityPool.reserves
       ],
       takerFeePercent: bridge.liquidityPool.takerFeePercent,
       withdrawalFeePercent: bridge.liquidityPool.withdrawalFeePercent
@@ -235,15 +174,12 @@ async function getReferenceFeedData(asset: any, referenceAsset: any, coreAsset:
     return null;
   }
 
-  let assetPerBts = null;
   let btsPerAsset = null;
 
   if (settlementPrice.base.asset_id === asset.id && settlementPrice.quote.asset_id === coreAsset.id) {
-    assetPerBts = basePerQuote;
     btsPerAsset = 1 / basePerQuote;
   } else if (settlementPrice.base.asset_id === coreAsset.id && settlementPrice.quote.asset_id === asset.id) {
     btsPerAsset = basePerQuote;
-    assetPerBts = 1 / basePerQuote;
   } else {
     return null;
   }
@@ -345,7 +281,6 @@ async function main() {
   const scopedAssets = options.allMpas
     ? allAssets.filter(isMpa).sort((a, b) => a.symbol.localeCompare(b.symbol))
     : allAssets.filter((asset) => asset?.symbol?.startsWith(options.prefix)).sort((a, b) => a.symbol.localeCompare(b.symbol));
-  const mpas = scopedAssets.filter(isMpa);
   const assetMap = new Map([coreAsset, referenceAsset, ...scopedAssets].filter(Boolean).map((asset) => [asset.id, asset]));
 
   const scopedAssetRecords = await mapWithConcurrency(scopedAssets, 4, async (asset: any) => {

package/claw/scripts/memu_mcp_server.ts

@@ -4,13 +4,43 @@
 // the full claw catalog (via claw_manifest), so suppress incidental console
 // logs the same way claw_mcp_server does.
 
-import { describeMemuBridge } from '../modules/memu_bridge.js';
-import { success, failure, runMcpServer, createMessageParser } from '../modules/mcp_utils.js';
-import { runMemuCommand } from '../modules/memu_bridge.js';
+import { createJsonRpcToolsHandler, jsonRpcError, runMcpServer } from '../modules/mcp_utils.js';
+import { runMemuCommand, validateMemuCommandArgs } from '../modules/memu_bridge.js';
 import { pathToFileURL } from 'node:url';
+import { getErrorMessage } from '../../modules/utils/errors.js';
 
 console.log = () => {};
 console.warn = () => {};
+
+// MCP tool name -> runMemuCommand command.
+const TOOL_COMMANDS: Record<string, string> = {
+  'memu_manifest': 'manifest',
+  'memu_memorize': 'memorize',
+  'memu_retrieve': 'retrieve',
+  'memu_list_categories': 'list-categories',
+  'memu_list_items': 'list-items',
+  'memu_create_item': 'create-item',
+  'memu_update_item': 'update-item',
+  'memu_delete_item': 'delete-item',
+  'memu_clear': 'clear',
+  'memu_status': 'status',
+  'memu_memorize_conversation': 'memorize-conversation',
+  'memu_memorize_trading_context': 'memorize-trading-context',
+  'memu_retrieve_trading_context': 'retrieve-trading-context'
+};
+
+/**
+ * Redact a CLI argument that may carry secrets (LLM API keys, database DSNs).
+ * Malformed JSON must be reported without echoing the full raw value into
+ * error messages or process logs.
+ */
+function redactSensitiveArg(value: any) {
+  const text = String(value);
+  const prefixLength = 12;
+  const prefix = text.slice(0, Math.min(prefixLength, text.length));
+  return `${prefix}<...${text.length} chars redacted>`;
+}
+
 function parseArgs(argv: any) {
   const options: Record<string, any> = {};
 
@@ -33,8 +63,8 @@ function parseArgs(argv: any) {
     if (arg === '--llm-profile' && next) {
       try {
         options.llmProfiles = JSON.parse(next);
-      } catch (e) {
-        throw new Error(`Invalid JSON for --llm-profile: ${next}`);
+      } catch {
+        throw new Error(`Invalid JSON for --llm-profile: ${redactSensitiveArg(next)}`);
       }
       i += 1;
       continue;
@@ -43,8 +73,8 @@ function parseArgs(argv: any) {
     if (arg === '--db-config' && next) {
       try {
         options.databaseConfig = JSON.parse(next);
-      } catch (e) {
-        throw new Error(`Invalid JSON for --db-config: ${next}`);
+      } catch {
+        throw new Error(`Invalid JSON for --db-config: ${redactSensitiveArg(next)}`);
       }
       i += 1;
       continue;
@@ -54,7 +84,7 @@ function parseArgs(argv: any) {
   return options;
 }
 
-function listMcpTools() {
+async function listMcpTools() {
   return [
     {
       name: 'memu_manifest',
@@ -286,158 +316,31 @@ function listMcpTools() {
   ];
 }
 
-async function handleRequest(message: any, defaults: any) {
-  const { id, method, params } = message;
-
-  switch (method) {
-    case 'initialize':
-      return success(id, {
-        // Echo the client's requested protocol version when provided (JSONL
-        // transport; see claw_runtime_matrix.ts).
-        protocolVersion: params?.protocolVersion || '2024-11-05',
-        capabilities: {
-          tools: {
-            listChanged: false
-          }
-        },
-        serverInfo: {
-          name: 'bitshares-memu',
-          version: '0.1.0'
-        }
-      });
-
-    case 'notifications/initialized':
-      return;
-
-    case 'ping':
-      return success(id, {});
-
-    case 'tools/list':
-      return success(id, {
-        tools: listMcpTools()
-      });
-
-    case 'tools/call': {
-      const toolName = params?.name;
-      const args = params?.arguments || {};
-
-      try {
-        let result;
-
-        switch (toolName) {
-          case 'memu_manifest':
-            result = describeMemuBridge(defaults);
-            break;
-
-          case 'memu_memorize':
-            if (!args.resourceUrl || !args.modality) {
-              return failure(id, -32602, 'memu_memorize requires resourceUrl and modality');
-            }
-            result = await runMemuTool('memorize', args, defaults);
-            break;
-
-          case 'memu_retrieve':
-            if (!args.queries) {
-              return failure(id, -32602, 'memu_retrieve requires queries');
-            }
-            result = await runMemuTool('retrieve', args, defaults);
-            break;
-
-          case 'memu_list_categories':
-            result = await runMemuTool('list-categories', args, defaults);
-            break;
-
-          case 'memu_list_items':
-            result = await runMemuTool('list-items', args, defaults);
-            break;
-
-          case 'memu_create_item':
-            if (!(args.categoryId || args.categoryName) || !args.summary) {
-              return failure(id, -32602, 'memu_create_item requires categoryId or categoryName, plus summary');
-            }
-            result = await runMemuTool('create-item', args, defaults);
-            break;
-
-          case 'memu_update_item':
-            if (!args.itemId || !args.updates) {
-              return failure(id, -32602, 'memu_update_item requires itemId and updates');
-            }
-            result = await runMemuTool('update-item', args, defaults);
-            break;
-
-          case 'memu_delete_item':
-            if (!args.itemId) {
-              return failure(id, -32602, 'memu_delete_item requires itemId');
-            }
-            result = await runMemuTool('delete-item', args, defaults);
-            break;
-
-          case 'memu_clear':
-            result = await runMemuTool('clear', args, defaults);
-            break;
-
-          case 'memu_status':
-            result = await runMemuTool('status', args, defaults);
-            break;
-
-          case 'memu_memorize_conversation':
-            if (!args.messages) {
-              return failure(id, -32602, 'memu_memorize_conversation requires messages');
-            }
-            result = await runMemuTool('memorize-conversation', args, defaults);
-            break;
-
-          case 'memu_memorize_trading_context':
-            if (!args.context) {
-              return failure(id, -32602, 'memu_memorize_trading_context requires context');
-            }
-            result = await runMemuTool('memorize-trading-context', args, defaults);
-            break;
-
-          case 'memu_retrieve_trading_context':
-            if (!args.query) {
-              return failure(id, -32602, 'memu_retrieve_trading_context requires query');
-            }
-            result = await runMemuTool('retrieve-trading-context', args, defaults);
-            break;
-
-          default:
-            return failure(id, -32602, `Unknown tool: ${toolName}`);
-        }
-
-        return success(id, {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2)
-            }
-          ],
-          structuredContent: result
-        });
-      } catch (error: any) {
-        return success(id, {
-          content: [
-            {
-              type: 'text',
-              text: error && error.stack ? error.stack : String(error)
-            }
-          ],
-          isError: true
-        });
-      }
-    }
+async function callTool(params: any, defaults: any) {
+  const toolName = params?.name;
+  const command = TOOL_COMMANDS[toolName];
+  if (!command) {
+    throw jsonRpcError(-32602, `Unknown tool: ${toolName}`);
+  }
 
-    default:
-      if (id !== undefined) {
-        return failure(id, -32601, `Method not found: ${method}`);
-      }
+  const args = params?.arguments || {};
+  // Shared validation with runMemuCommand/claw_bridge so every surface rejects
+  // missing args with the same message; surfaced as invalid params (-32602).
+  try {
+    validateMemuCommandArgs(command, { ...defaults, ...args });
+  } catch (err: any) {
+    throw jsonRpcError(-32602, getErrorMessage(err));
   }
-}
 
-async function runMemuTool(command: any, args: any, defaults: any) {
   return runMemuCommand(command, { ...defaults, ...args });
 }
 
+const handleRequest = createJsonRpcToolsHandler({
+  serverName: 'bitshares-memu',
+  listTools: listMcpTools,
+  callTool
+});
+
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   runMcpServer(parseArgs, handleRequest).catch((err: unknown) => {
     process.stderr.write(`${err instanceof Error && err.stack ? err.stack : String(err)}\n`);
@@ -445,5 +348,4 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   });
 }
 
-export { createMessageParser, failure, handleRequest, listMcpTools, success }
 

package/claw/tests/test_claw_bridge.ts

@@ -225,6 +225,9 @@ function createBridgeHarness() {
     }
   });
 
+  // Snapshot the real validator before the mock replaces the module: claw
+  // bridge delegates memu-* argument validation to it.
+  const realMemuBridge = require(memuBridgePath);
   registerMock(memuBridgePath, {
     describeMemuBridge: (options: any) => ({
       options,
@@ -238,7 +241,8 @@ function createBridgeHarness() {
         options,
         source: 'memu'
       };
-    }
+    },
+    validateMemuCommandArgs: realMemuBridge.validateMemuCommandArgs
   });
 
   clearModule(bridgePath);
@@ -499,7 +503,7 @@ async function testRunClawCommandDispatchMatrix() {
       () => bridge.runClawCommand('memu-create-item', {
         summary: 'missing category'
       }),
-      /memu-create-item requires categoryId or categoryName, plus summary/
+      /create-item requires categoryId or categoryName, plus summary/
     );
 
     await assert.rejects(

package/claw/tests/test_claw_mcp_transport.ts

@@ -31,7 +31,7 @@ async function testParserAcceptsJsonlAcrossChunksAndSingleBuffer() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.4.20'
+        version: '1.4.21'
       },
       protocolVersion: '2024-11-05'
     }
@@ -182,7 +182,7 @@ async function testMainEntrypointHandlesRealProcessInitialize() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.4.20'
+        version: '1.4.21'
       },
       protocolVersion: '2024-11-05'
     }

package/dist/analysis/ama_fitting/calibrate_convergence_er.js

@@ -85,7 +85,7 @@ function main() {
         if (e.code === 'ENOENT') {
             console.error(`Data file not found: ${opts.data}`);
             console.error('Export LP candles first, or point --data at an existing file.');
-            console.error('  tsx market_adapter/inputs/fetch_lp_data.ts --pool 133 --precA 4 --precB 5 --interval 1h --lookback 26280h');
+            console.error('  node dist/market_adapter/inputs/fetch_lp_data.js --pool 133 --precA 4 --precB 5 --interval 1h --lookback 26280h');
         }
         else if (e instanceof SyntaxError) {
             console.error(`Failed to parse JSON from: ${opts.data}`);