dexbot 1.4.13 → 1.4.15

package/claw/tests/test_claw_data_flow.ts

@@ -3,11 +3,11 @@
 const assert = require('assert');
 const Module = require('module');
 
-function clearModule(modulePath) {
+function clearModule(modulePath: string) {
   delete require.cache[modulePath];
 }
 
-function registerMock(modulePath, exports) {
+function registerMock(modulePath: string, exports: any) {
   require.cache[modulePath] = {
     id: modulePath,
     filename: modulePath,
@@ -25,11 +25,11 @@ function createChainDataHarness() {
   const feedPath = require.resolve('../modules/feed_price_source');
 
   const calls = {
-    dbCall: [],
-    getAsset: [],
-    getBackingAsset: [],
-    getBitassetData: [],
-    getFullAccount: []
+    dbCall: [] as Array<{ method: string; args: unknown }>,
+    getAsset: [] as string[],
+    getBackingAsset: [] as string[],
+    getBitassetData: [] as string[],
+    getFullAccount: [] as string[]
   };
 
   const bts = { id: '1.3.0', precision: 5, symbol: 'BTS' };
@@ -67,15 +67,15 @@ function createChainDataHarness() {
 
   registerMock(bridgePath, {
     loadDexbotOrderUtils: () => ({
-      blockchainToFloat: (amount, precision) => Number(amount) / (10 ** precision)
+      blockchainToFloat: (amount: number, precision: number) => Number(amount) / (10 ** precision)
     }),
     loadDexbotOrderSystemUtils: () => ({
-      blockchainToFloat: (amount, precision) => Number(amount) / (10 ** precision)
+      blockchainToFloat: (amount: number, precision: number) => Number(amount) / (10 ** precision)
     })
   });
 
   registerMock(queriesPath, {
-    getAsset: async (symbolOrId) => {
+    getAsset: async (symbolOrId: string) => {
       calls.getAsset.push(symbolOrId);
       if (symbolOrId === 'BTS' || symbolOrId === bts.id) {
         return bts;
@@ -88,7 +88,7 @@ function createChainDataHarness() {
       }
       return null;
     },
-    getBackingAsset: async (symbolOrId) => {
+    getBackingAsset: async (symbolOrId: string) => {
       calls.getBackingAsset.push(symbolOrId);
       if (symbolOrId === honest.id || symbolOrId === honest.symbol) {
         return bts;
@@ -98,7 +98,7 @@ function createChainDataHarness() {
       }
       return null;
     },
-    getBitassetData: async (symbolOrId) => {
+    getBitassetData: async (symbolOrId: string) => {
       calls.getBitassetData.push(symbolOrId);
       if (symbolOrId === honest.id || symbolOrId === honest.symbol) {
         return {
@@ -124,14 +124,14 @@ function createChainDataHarness() {
       }
       return null;
     },
-    getFullAccount: async (accountName) => {
+    getFullAccount: async (accountName: string) => {
       calls.getFullAccount.push(accountName);
       if (accountName !== 'alice') {
         return null;
       }
       return clone(account);
     },
-    dbCall: async (method, args) => {
+    dbCall: async (method: string, args: unknown) => {
       calls.dbCall.push({ method, args: clone(args) });
       if (method === 'get_order_book') {
         return {
@@ -213,22 +213,22 @@ function createDecisionLoopHarness() {
   const discoveryPath = require.resolve('../modules/position_discovery');
   const healthPath = require.resolve('../modules/position_health');
   const feedPath = require.resolve('../modules/feed_price_source');
-  const analyzerPath = require.resolve('../../analysis/trend_detection/kalman_trend_analyzer');
+  const analyzerPath = require.resolve('../../market_adapter/core/signals/kalman_trend_analyzer');
 
   const calls = {
-    fetchTrendInput: [],
-    log: [],
-    updates: []
+    fetchTrendInput: [] as string[],
+    log: [] as string[],
+    updates: [] as Array<{ positionId: string; trendSignal: any }>
   };
 
   class FakeTrendAnalyzer {
     [key: string]: any;
-    constructor(config) {
+    constructor(config: any) {
       this.config = config;
       this.updateCount = 0;
     }
 
-    update(marketPrice, feedPrice) {
+    update(marketPrice: number, feedPrice: number) {
       this.updateCount += 1;
       this.lastResult = {
         confidence: 80,
@@ -255,7 +255,7 @@ function createDecisionLoopHarness() {
     ])
   });
   registerMock(healthPath, {
-    assessPosition: (position, trendSignal) => {
+    assessPosition: (position: any, trendSignal: any) => {
       calls.updates.push({ positionId: position.id, trendSignal: clone(trendSignal) });
       return {
         actions: position.id === 'pos-1'
@@ -267,7 +267,7 @@ function createDecisionLoopHarness() {
     }
   });
   registerMock(feedPath, {
-    fetchTrendInput: async (mpaSymbol) => {
+    fetchTrendInput: async (mpaSymbol: string) => {
       calls.fetchTrendInput.push(mpaSymbol);
       if (mpaSymbol === 'HONEST.EUR') {
         throw new Error('feed unavailable');
@@ -306,7 +306,7 @@ async function testDecisionLoop() {
   try {
     const result = await decisionLoop.evaluate('alice', {
       analyzerConfig: { period: 12 },
-      logger: (message) => calls.log.push(message)
+      logger: (message: string) => calls.log.push(message)
     });
 
     assert.strictEqual(result.positionCount, 3);
@@ -336,19 +336,19 @@ function createKibanaHarness() {
   const kibanaPricePath = require.resolve('../modules/kibana_price_source');
 
   const calls = {
-    getAsset: [],
-    marketCandles: [],
-    marketClosePrices: [],
-    lpCandles: [],
-    lpClosePrices: [],
-    poolAssets: []
+    getAsset: [] as string[],
+    marketCandles: [] as Array<{ assetA: any; assetB: any; config: any }>,
+    marketClosePrices: [] as Array<{ assetA: any; assetB: any; config: any }>,
+    lpCandles: [] as Array<{ poolId: any; assetA: any; assetB: any; config: any }>,
+    lpClosePrices: [] as Array<{ poolId: any; assetA: any; assetB: any; config: any }>,
+    poolAssets: [] as Array<{ poolId: any; config: any }>
   };
 
   const bts = { id: '1.3.0', precision: 5, symbol: 'BTS' };
   const honest = { id: '1.3.100', precision: 5, symbol: 'HONEST.USD' };
 
   registerMock(chainQueriesPath, {
-    getAsset: async (symbolOrId) => {
+    getAsset: async (symbolOrId: string) => {
       calls.getAsset.push(symbolOrId);
       if (symbolOrId === 'BTS') {
         return bts;
@@ -360,25 +360,25 @@ function createKibanaHarness() {
     }
   });
   registerMock(marketCandlesPath, {
-    getMarketCandles: async (assetA, assetB, config) => {
+    getMarketCandles: async (assetA: any, assetB: any, config: any) => {
       calls.marketCandles.push({ assetA, assetB, config: clone(config) });
       return [[1, 2, 2, 2, 2, 10]];
     },
-    getMarketClosePrices: async (assetA, assetB, config) => {
+    getMarketClosePrices: async (assetA: any, assetB: any, config: any) => {
       calls.marketClosePrices.push({ assetA, assetB, config: clone(config) });
       return [2];
     }
   });
   registerMock(lpSourcePath, {
-    discoverPoolAssets: async (poolId, config) => {
+    discoverPoolAssets: async (poolId: any, config: any) => {
       calls.poolAssets.push({ poolId, config: clone(config) });
       return ['1.3.0', '1.3.100'];
     },
-    getLpCandlesForPool: async (poolId, assetA, assetB, config) => {
+    getLpCandlesForPool: async (poolId: any, assetA: any, assetB: any, config: any) => {
       calls.lpCandles.push({ poolId, assetA, assetB, config: clone(config) });
       return [[2, 3, 3, 3, 3, 4]];
     },
-    getLpClosePricesForPool: async (poolId, assetA, assetB, config) => {
+    getLpClosePricesForPool: async (poolId: any, assetA: any, assetB: any, config: any) => {
       calls.lpClosePrices.push({ poolId, assetA, assetB, config: clone(config) });
       return [3];
     }
@@ -440,8 +440,8 @@ function createLiquidityHarness() {
   const poolsPath = require.resolve('../modules/liquidity_pools');
   const sharedBitShares = { name: 'shared-bitshares-client' };
   const calls = {
-    pool: null,
-    price: null
+    pool: null as any,
+    price: null as any
   };
 
   registerMock(bitsharesPath, {
@@ -450,13 +450,13 @@ function createLiquidityHarness() {
   registerMock(bridgePath, {
     getDexbot2Root: () => '/tmp',
     loadDexbotOrderSystemUtils: () => ({
-      cloneMap: (value) => value,
-      deepFreeze: (value) => value,
-      derivePoolPrice: (...args) => {
+      cloneMap: (value: any) => value,
+      deepFreeze: (value: any) => value,
+      derivePoolPrice: (...args: any[]) => {
         calls.pool = args;
         return 'pool-price';
       },
-      derivePrice: (...args) => {
+      derivePrice: (...args: any[]) => {
         calls.price = args;
         return 'derived-price';
       },

package/claw/tests/test_claw_domain_logic.ts

@@ -5,11 +5,11 @@ const fs = require('fs/promises');
 const os = require('os');
 const path = require('path');
 
-function clearModule(modulePath) {
+function clearModule(modulePath: string) {
   delete require.cache[modulePath];
 }
 
-function registerMock(modulePath, exports) {
+function registerMock(modulePath: string, exports: any) {
   require.cache[modulePath] = {
     id: modulePath,
     filename: modulePath,
@@ -26,12 +26,12 @@ function createHonestHarness(options: any = {}) {
   const poolsPath = require.resolve('../modules/liquidity_pools');
 
   const calls = {
-    derivePoolPrice: [],
-    getAsset: [],
-    getBackingAsset: [],
-    getBitassetData: [],
-    getCallOrders: [],
-    listAssets: []
+    derivePoolPrice: [] as any[],
+    getAsset: [] as string[],
+    getBackingAsset: [] as string[],
+    getBitassetData: [] as string[],
+    getCallOrders: [] as any[],
+    listAssets: [] as any[]
   };
 
   const coreAsset = { id: '1.3.0', precision: 5, symbol: 'BTS' };
@@ -62,7 +62,7 @@ function createHonestHarness(options: any = {}) {
       ];
 
   registerMock(queriesPath, {
-    getAsset: async (symbolOrId) => {
+    getAsset: async (symbolOrId: string) => {
       calls.getAsset.push(symbolOrId);
       if (symbolOrId === 'BTS' || symbolOrId === '1.3.0') {
         return coreAsset;
@@ -78,11 +78,11 @@ function createHonestHarness(options: any = {}) {
       }
       return null;
     },
-    getBackingAsset: async (assetId) => {
+    getBackingAsset: async (assetId: string) => {
       calls.getBackingAsset.push(assetId);
       return coreAsset;
     },
-    getBitassetData: async (assetId) => {
+    getBitassetData: async (assetId: string) => {
       calls.getBitassetData.push(assetId);
       return {
         current_feed_publication_time: `2026-03-31T00:00:0${assetId === '1.3.100' ? '1' : assetId === '1.3.101' ? '2' : '3'}`,
@@ -94,18 +94,18 @@ function createHonestHarness(options: any = {}) {
         }
       };
     },
-    getCallOrders: async (assetId, limit) => {
+    getCallOrders: async (assetId: string, limit: any) => {
       calls.getCallOrders.push({ assetId, limit });
       return [{ id: `${assetId}-call-1` }];
     },
-    listAssets: async (lowerBound, limit) => {
+    listAssets: async (lowerBound: string, limit: any) => {
       calls.listAssets.push({ lowerBound, limit });
       return listAssetPages.shift() || [];
     }
   });
 
   registerMock(poolsPath, {
-    derivePoolPrice: async (assetA, assetB, options) => {
+    derivePoolPrice: async (assetA: any, assetB: any, options: any) => {
       calls.derivePoolPrice.push({ assetA, assetB, options: clone(options) });
       if (typeof options.failPair === 'string' && `${assetA}/${assetB}` === options.failPair) {
         throw new Error('pair unavailable');
@@ -229,7 +229,7 @@ async function testHonestEcosystemPaginationAndUnresolvedPair() {
     });
 
     assert.deepStrictEqual(
-      loaded.assets.map((asset) => asset.symbol),
+      loaded.assets.map((asset: any) => asset.symbol),
       ['HONEST.MONEY', 'HONEST.USD', 'HONEST.EUR']
     );
     assert.deepStrictEqual(calls.listAssets, [
@@ -260,10 +260,10 @@ function createPositionManagerHarness() {
   const shortStrategyPath = require.resolve('../modules/short_mpa_strategy');
 
   const calls = {
-    savedStates: [],
-    syncPosition: [],
-    listenForFills: [],
-    onFill: []
+    savedStates: [] as any[],
+    syncPosition: [] as string[],
+    listenForFills: [] as any[],
+    onFill: [] as any[]
   };
 
   const coreAsset = { id: '1.3.0', precision: 5, symbol: 'BTS' };
@@ -282,12 +282,12 @@ function createPositionManagerHarness() {
 
   registerMock(bridgePath, {
     loadDexbotOrderUtils: () => ({
-      blockchainToFloat: (amount, precision) => Number(amount) / (10 ** precision)
+      blockchainToFloat: (amount: number, precision: number) => Number(amount) / (10 ** precision)
     })
   });
 
   registerMock(profilesPath, {
-    writeJsonFileAtomic: async (filePath, state) => {
+    writeJsonFileAtomic: async (filePath: string, state: any) => {
       calls.savedStates.push({
         filePath,
         state: clone(state)
@@ -296,7 +296,7 @@ function createPositionManagerHarness() {
   });
 
   registerMock(actionsPath, {
-    listenForFills: async (accountName, callback) => {
+    listenForFills: async (accountName: string, callback: any) => {
       calls.listenForFills.push({ accountName, callback });
       return async () => {
         calls.listenForFills.push({ accountName, callback, type: 'unsubscribe' });
@@ -311,7 +311,7 @@ function createPositionManagerHarness() {
   });
 
   registerMock(queriesPath, {
-    getAsset: async (symbolOrId) => {
+    getAsset: async (symbolOrId: string) => {
       if (symbolOrId === 'HONEST.USD' || symbolOrId === '1.3.100') {
         return mpaAsset;
       }
@@ -359,7 +359,7 @@ function createPositionManagerHarness() {
     },
     manager,
     mpaAsset,
-    setAccountSnapshot(nextSnapshot) {
+    setAccountSnapshot(nextSnapshot: any) {
       accountSnapshot = clone(nextSnapshot);
     }
   };
@@ -411,12 +411,12 @@ async function testPositionManager() {
     assert.strictEqual(synced.onChain.trackedOrders.entry.orderId, '1.7.1');
     assert.strictEqual(synced.onChain.trackedOrders.entry.sellAmountRemaining, 5);
 
-    manager.syncPosition = async (positionId) => {
+    manager.syncPosition = async (positionId: string) => {
       calls.syncPosition.push(positionId);
       return manager.getPosition(positionId);
     };
 
-    const unsubscribe = await manager.watchAccount('alice', async (position, fill) => {
+    const unsubscribe = await manager.watchAccount('alice', async (position: any, fill: any) => {
       calls.onFill.push({ fill, position });
     });
 

package/claw/tests/test_claw_manifest_and_matrix.ts

@@ -13,7 +13,7 @@ function testRuntimeMatrix() {
   const all = matrix.listSupportedClawRuntimes();
   assert.ok(all.length >= 9);
 
-  const names = all.map((r) => r.runtime);
+  const names = all.map((r: any) => r.runtime);
   assert.deepStrictEqual(names, ['openclaw', 'hermes', 'openfang', 'nanobot', 'picoclaw', 'nanoclaw', 'zeroclaw', 'nullclaw', 'memu']);
 
   // Each entry is a defensive clone — mutations must not affect the registry

package/claw/tests/test_claw_mcp_transport.ts

@@ -9,17 +9,17 @@ const path = require('path');
 const { isDistCodeRoot } = require('../../modules/launcher/runtime_entry');
 const mcpServer = require('../scripts/claw_mcp_server');
 
-function encodeNewlineMessage(message) {
+function encodeNewlineMessage(message: any) {
   return `${JSON.stringify(message)}\n`;
 }
 
-function shellQuote(value) {
+function shellQuote(value: any) {
   return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
 }
 
 async function testParserAcceptsJsonlAcrossChunksAndSingleBuffer() {
-  const seen = [];
-  const parser = mcpServer.createMessageParser((message) => {
+  const seen: any[] = [];
+  const parser = mcpServer.createMessageParser((message: any) => {
     seen.push(message);
   });
 
@@ -31,7 +31,7 @@ async function testParserAcceptsJsonlAcrossChunksAndSingleBuffer() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.4.13'
+        version: '1.4.15'
       },
       protocolVersion: '2024-11-05'
     }
@@ -66,8 +66,8 @@ async function testParserAcceptsJsonlAcrossChunksAndSingleBuffer() {
 }
 
 async function testParserIgnoresLegacyContentLengthFrames() {
-  const seen = [];
-  const parser = mcpServer.createMessageParser((message) => {
+  const seen: any[] = [];
+  const parser = mcpServer.createMessageParser((message: any) => {
     seen.push(message);
   });
 
@@ -84,7 +84,7 @@ async function testParserIgnoresLegacyContentLengthFrames() {
 
 async function testHandleRequestEmitsNewlineJson() {
   const repoRoot = path.resolve(__dirname, '..', '..');
-  const captured = [];
+  const captured: any[] = [];
   const originalWrite = process.stdout.write;
 
   process.stdout.write = ((chunk: any, encoding: any, callback: any) => {
@@ -132,17 +132,17 @@ async function testHandleRequestEmitsNewlineJson() {
   assert.strictEqual(responses[1].id, 2);
   assert.ok(Array.isArray(responses[1].result.tools), 'tools/list should return a tool list');
   assert.ok(
-    responses[1].result.tools.some((tool) => tool.name === 'claw_runtime'),
+    responses[1].result.tools.some((tool: any) => tool.name === 'claw_runtime'),
     'tools/list should include claw_runtime'
   );
   assert.strictEqual(
-    responses[1].result.tools.some((tool) => String(tool.name).startsWith('mcp_claw_')),
+    responses[1].result.tools.some((tool: any) => String(tool.name).startsWith('mcp_claw_')),
     false,
     'tools/list should expose the raw claw_* tool ids from the MCP server'
   );
 }
 
-function runServerProcess(input) {
+function runServerProcess(input: any) {
   const repoRoot = path.resolve(__dirname, '..', '..');
   const clawRoot = path.resolve(__dirname, '..');
   const _isDist = isDistCodeRoot(path.dirname(__dirname));
@@ -182,7 +182,7 @@ async function testMainEntrypointHandlesRealProcessInitialize() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.4.13'
+        version: '1.4.15'
       },
       protocolVersion: '2024-11-05'
     }
@@ -204,9 +204,9 @@ async function testMainEntrypointHandlesRealProcessInitialize() {
 
   const responses = run.stdout
     .split('\n')
-    .map((line) => line.trim())
+    .map((line: any) => line.trim())
     .filter((x: any) => x)
-    .map((line) => JSON.parse(line));
+    .map((line: any) => JSON.parse(line));
 
   assert.strictEqual(responses.length, 2, 'expected two JSON-RPC responses from the entrypoint');
   assert.strictEqual(responses[0].id, 1);
@@ -214,11 +214,11 @@ async function testMainEntrypointHandlesRealProcessInitialize() {
   assert.strictEqual(responses[1].id, 2);
   assert.ok(Array.isArray(responses[1].result.tools), 'tools/list should return a tool array');
   assert.ok(
-    responses[1].result.tools.some((tool) => tool.name === 'claw_manifest'),
+    responses[1].result.tools.some((tool: any) => tool.name === 'claw_manifest'),
     'tools/list should include claw_manifest'
   );
   assert.strictEqual(
-    responses[1].result.tools.some((tool) => String(tool.name).startsWith('mcp_claw_')),
+    responses[1].result.tools.some((tool: any) => String(tool.name).startsWith('mcp_claw_')),
     false,
     'entrypoint should expose raw claw_* tool ids from the MCP server'
   );