dexbot 1.4.13 → 1.4.14

package/claw/tests/test_claw_bridge.ts

@@ -2,11 +2,11 @@
 
 const assert = require('assert');
 
-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,
@@ -23,34 +23,34 @@ function createBridgeHarness() {
   const shortStrategyPath = require.resolve('../modules/short_mpa_strategy');
 
   const calls = {
-    createClawInfrastructure: [],
+    createClawInfrastructure: [] as any[],
     chainActions: {
-      adjustMpaCollateral: [],
-      borrowMpa: [],
-      buildUpdateLimitOrderOperation: [],
-      cancelLimitOrder: [],
-      createLimitOrder: [],
-      executeBatch: [],
-      getMpaPosition: [],
-      getOpenOrders: [],
-      repayMpaDebt: [],
-      settleMpa: [],
-      updateLimitOrder: []
+      adjustMpaCollateral: [] as any[],
+      borrowMpa: [] as any[],
+      buildUpdateLimitOrderOperation: [] as any[],
+      cancelLimitOrder: [] as any[],
+      createLimitOrder: [] as any[],
+      executeBatch: [] as any[],
+      getMpaPosition: [] as any[],
+      getOpenOrders: [] as any[],
+      repayMpaDebt: [] as any[],
+      settleMpa: [] as any[],
+      updateLimitOrder: [] as any[]
     },
     shortStrategy: {
-      buildCloseShortPlan: [],
-      buildOpenShortPlan: [],
-      buildTakeProfitPlan: [],
-      closeShortOnBts: [],
-      openShortOnBts: [],
-      placeTakeProfitBuyOrderOnBts: []
+      buildCloseShortPlan: [] as any[],
+      buildOpenShortPlan: [] as any[],
+      buildTakeProfitPlan: [] as any[],
+      closeShortOnBts: [] as any[],
+      openShortOnBts: [] as any[],
+      placeTakeProfitBuyOrderOnBts: [] as any[]
     },
     profiles: {
-      getBotSettings: [],
-      previewBotSettingsUpdate: [],
-      applyBotSettingsPatch: []
+      getBotSettings: [] as any[],
+      previewBotSettingsUpdate: [] as any[],
+      applyBotSettingsPatch: [] as any[]
     },
-    memu: []
+    memu: [] as any[]
   };
 
   const bridgeRuntime = {
@@ -60,21 +60,21 @@ function createBridgeHarness() {
   };
 
   registerMock(infraPath, {
-    createClawInfrastructure: (options) => {
+    createClawInfrastructure: (options: any) => {
       calls.createClawInfrastructure.push(options);
       return {
         honest: {
-          buildContext: async (options) => ({
+          buildContext: async (options: any) => ({
             source: 'honest-context',
             options
           }),
-          resolvePairContext: async (assetA, assetB, options) => ({
+          resolvePairContext: async (assetA: any, assetB: any, options: any) => ({
             assetA,
             assetB,
             options,
             source: 'honest-pair'
           }),
-          resolvePairPrice: async (assetA, assetB, options) => ({
+          resolvePairPrice: async (assetA: any, assetB: any, options: any) => ({
             assetA,
             assetB,
             options,
@@ -82,11 +82,11 @@ function createBridgeHarness() {
           })
         },
         market: {
-          readAccountSnapshot: async (accountName) => ({
+          readAccountSnapshot: async (accountName: any) => ({
             accountName,
             source: 'account-snapshot'
           }),
-          readMarketSnapshot: async (baseSymbol, quoteSymbol, limit) => ({
+          readMarketSnapshot: async (baseSymbol: any, quoteSymbol: any, limit: any) => ({
             baseSymbol,
             limit,
             quoteSymbol,
@@ -94,12 +94,12 @@ function createBridgeHarness() {
           })
         },
         profiles: {
-          getClawProfileContext: async (ref, options) => ({
+          getClawProfileContext: async (ref: any, options: any) => ({
             options,
             ref,
             selectedBot: { botId: ref, source: 'profile-context' }
           }),
-          getBotSettings: async (ref, forceReload) => {
+          getBotSettings: async (ref: any, forceReload: any) => {
             calls.profiles.getBotSettings.push({ forceReload, ref });
             return {
               forceReload,
@@ -107,7 +107,7 @@ function createBridgeHarness() {
               source: 'bot-settings'
             };
           },
-          previewBotSettingsUpdate: async (ref, patch, options) => {
+          previewBotSettingsUpdate: async (ref: any, patch: any, options: any) => {
             calls.profiles.previewBotSettingsUpdate.push({ options, patch, ref });
             return {
               options,
@@ -116,7 +116,7 @@ function createBridgeHarness() {
               source: 'bot-settings-preview'
             };
           },
-          applyBotSettingsPatch: async (ref, patch, options) => {
+          applyBotSettingsPatch: async (ref: any, patch: any, options: any) => {
             calls.profiles.applyBotSettingsPatch.push({ options, patch, ref });
             return {
               options,
@@ -136,8 +136,8 @@ function createBridgeHarness() {
     }
   });
 
-  const stubbedChainAction = (name) => async (options) => {
-    calls.chainActions[name].push(options);
+  const stubbedChainAction = (name: string) => async (options: any) => {
+    calls.chainActions[name as keyof typeof calls.chainActions].push(options);
     return {
       options,
       source: name
@@ -147,7 +147,7 @@ function createBridgeHarness() {
   registerMock(chainActionsPath, {
     adjustMpaCollateral: stubbedChainAction('adjustMpaCollateral'),
     borrowMpa: stubbedChainAction('borrowMpa'),
-    buildUpdateLimitOrderOperation: async (options) => {
+    buildUpdateLimitOrderOperation: async (options: any) => {
       calls.chainActions.buildUpdateLimitOrderOperation.push(options);
       return {
         op: {
@@ -160,7 +160,7 @@ function createBridgeHarness() {
     cancelLimitOrder: stubbedChainAction('cancelLimitOrder'),
     createLimitOrder: stubbedChainAction('createLimitOrder'),
     executeBatch: stubbedChainAction('executeBatch'),
-    getMpaPosition: async (accountNameOrId, mpaAsset) => {
+    getMpaPosition: async (accountNameOrId: any, mpaAsset: any) => {
       calls.chainActions.getMpaPosition.push({ accountNameOrId, mpaAsset });
       return {
         accountNameOrId,
@@ -168,7 +168,7 @@ function createBridgeHarness() {
         source: 'mpa-position'
       };
     },
-    getOpenOrders: async (accountNameOrId) => {
+    getOpenOrders: async (accountNameOrId: any) => {
       calls.chainActions.getOpenOrders.push(accountNameOrId);
       return {
         accountNameOrId,
@@ -181,42 +181,42 @@ function createBridgeHarness() {
   });
 
   registerMock(shortStrategyPath, {
-    buildCloseShortPlan: async (options) => {
+    buildCloseShortPlan: async (options: any) => {
       calls.shortStrategy.buildCloseShortPlan.push(options);
       return {
         options,
         source: 'buildCloseShortPlan'
       };
     },
-    buildOpenShortPlan: async (options) => {
+    buildOpenShortPlan: async (options: any) => {
       calls.shortStrategy.buildOpenShortPlan.push(options);
       return {
         options,
         source: 'buildOpenShortPlan'
       };
     },
-    buildTakeProfitPlan: async (options) => {
+    buildTakeProfitPlan: async (options: any) => {
       calls.shortStrategy.buildTakeProfitPlan.push(options);
       return {
         options,
         source: 'buildTakeProfitPlan'
       };
     },
-    closeShortOnBts: async (options) => {
+    closeShortOnBts: async (options: any) => {
       calls.shortStrategy.closeShortOnBts.push(options);
       return {
         options,
         source: 'closeShortOnBts'
       };
     },
-    openShortOnBts: async (options) => {
+    openShortOnBts: async (options: any) => {
       calls.shortStrategy.openShortOnBts.push(options);
       return {
         options,
         source: 'openShortOnBts'
       };
     },
-    placeTakeProfitBuyOrderOnBts: async (options) => {
+    placeTakeProfitBuyOrderOnBts: async (options: any) => {
       calls.shortStrategy.placeTakeProfitBuyOrderOnBts.push(options);
       return {
         options,
@@ -226,12 +226,12 @@ function createBridgeHarness() {
   });
 
   registerMock(memuBridgePath, {
-    describeMemuBridge: (options) => ({
+    describeMemuBridge: (options: any) => ({
       options,
       runtime: 'memu',
       source: 'describeMemuBridge'
     }),
-    runMemuCommand: async (command, options) => {
+    runMemuCommand: async (command: any, options: any) => {
       calls.memu.push({ command, options });
       return {
         command,

package/claw/tests/test_claw_catalog_and_credentials.ts

@@ -6,15 +6,15 @@ const net = require('net');
 const { EventEmitter } = require('events');
 const path = require('path');
 
-function clearModule(modulePath) {
+function clearModule(modulePath: string) {
   delete require.cache[modulePath];
 }
 
-function createMockConnection(script) {
-  return (socketPath, onConnect) => {
+function createMockConnection(script: any) {
+  return (socketPath: string, onConnect: any) => {
     const socket = new EventEmitter();
     socket.socketPath = socketPath;
-    socket.write = (payload) => {
+    socket.write = (payload: any) => {
       socket.payload = payload;
     };
     socket.end = () => {
@@ -55,8 +55,8 @@ function testClawCatalog() {
   assert.notStrictEqual(catalog.getClawToolCatalog()[0].command, 'mutated');
 
   const examples = catalog.buildClawCommandExamples('tsx scripts/claw_bridge.ts');
-  assert.ok(examples.some((line) => line.startsWith('tsx scripts/claw_bridge.ts manifest')));
-  assert.ok(examples.some((line) => line.includes('bot-settings-apply')));
+  assert.ok(examples.some((line: any) => line.startsWith('tsx scripts/claw_bridge.ts manifest')));
+  assert.ok(examples.some((line: any) => line.includes('bot-settings-apply')));
 }
 
 async function testCredentialDaemonClient() {
@@ -71,7 +71,7 @@ async function testCredentialDaemonClient() {
   const originalLstatSync = fs.lstatSync;
   const originalCreateConnection = net.createConnection;
 
-  const credStatFor = (filePath) => ({
+  const credStatFor = (filePath: any) => ({
     isSymbolicLink: () => false,
     isFile: () => !String(filePath).endsWith('.sock'),
     isSocket: () => String(filePath).endsWith('.sock'),
@@ -80,7 +80,7 @@ async function testCredentialDaemonClient() {
     mode: 0o100600,
   });
 
-  fs.lstatSync = (filePath) => {
+  fs.lstatSync = (filePath: any) => {
     if (String(filePath).includes('cred')) return credStatFor(filePath);
     return originalLstatSync.call(fs, filePath);
   };
@@ -90,7 +90,7 @@ async function testCredentialDaemonClient() {
     assert.strictEqual(client.DEFAULT_READY_FILE, runtime.getCredentialReadyFilePath());
 
     let readyChecks = 0;
-    fs.existsSync = (filePath) => {
+    fs.existsSync = (filePath: any) => {
       if (String(filePath).includes('cred')) {
         readyChecks += 1;
         return readyChecks >= 2;

package/claw/tests/test_claw_chain_layer.ts

@@ -2,11 +2,11 @@
 
 const assert = require('assert');
 
-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,
@@ -23,8 +23,8 @@ function createQueriesHarness() {
   const dexbotBridgePath = require.resolve('../modules/dexbot_bridge');
 
   const calls = {
-    dbCall: [],
-    lookupAsset: [],
+    dbCall: [] as Array<{ args: unknown; method: string }>,
+    lookupAsset: [] as string[],
     waitForConnected: 0
   };
 
@@ -77,13 +77,13 @@ function createQueriesHarness() {
         get_dynamic_global_properties: async () => ({
           head_block_number: 100
         }),
-        get_assets: async (ids) => ids.map((id) => assets[id]).filter((x: any) => x),
-        get_objects: async (ids) => ids.map((id) => objects[id] || null),
-        call: async (method, args) => {
+        get_assets: async (ids: any[]) => ids.map((id: any) => assets[id as keyof typeof assets]).filter((x: any) => x),
+        get_objects: async (ids: any[]) => ids.map((id: any) => objects[id as keyof typeof objects] || null),
+        call: async (method: string, args: any) => {
           calls.dbCall.push({ args: clone(args), method });
 
           if (method === 'lookup_asset_symbols') {
-            return args[0].map((symbol) => {
+            return args[0].map((symbol: any) => {
               if (symbol === 'FALLBACK') {
                 return assets['1.3.101'];
               }
@@ -110,7 +110,7 @@ function createQueriesHarness() {
 
   registerMock(dexbotBridgePath, {
     loadDexbotOrderSystemUtils: () => ({
-      lookupAsset: async (_bitshares, symbolOrId) => {
+      lookupAsset: async (_bitshares: any, symbolOrId: string) => {
         calls.lookupAsset.push(symbolOrId);
         if (symbolOrId === 'FALLBACK') {
           throw new Error('lookup failure');
@@ -125,7 +125,7 @@ function createQueriesHarness() {
       }
     }),
     loadDexbotOrderUtils: () => ({
-      blockchainToFloat: (amount, precision) => Number(amount) / (10 ** precision)
+      blockchainToFloat: (amount: number, precision: number) => Number(amount) / (10 ** precision)
     })
   });
 
@@ -197,32 +197,32 @@ function createBroadcastHarness() {
   const credentialClientPath = require.resolve('../modules/dexbot_credential_client');
 
   const calls = {
-    accountClient: [],
-    broadcasts: [],
+    accountClient: [] as Array<{ accountName: any; privateKey: any }>,
+    broadcasts: [] as any[],
     daemon: {
-      broadcast: [],
-      execute: [],
-      wait: []
+      broadcast: [] as Array<{ accountName: any; operation: any; options: any }>,
+      execute: [] as Array<{ accountName: any; operations: any; options: any }>,
+      wait: [] as Array<{ timeoutMs: any; options: any }>
     },
     daemonReady: false,
     newTx: 0,
-    txOps: []
+    txOps: [] as Array<{ opData: any; opName: string }>
   };
 
   const tx = {
-    asset_settle: (opData) => {
+    asset_settle: (opData: any) => {
       calls.txOps.push({ opData, opName: 'asset_settle' });
       return tx;
     },
-    call_order_update: (opData) => {
+    call_order_update: (opData: any) => {
       calls.txOps.push({ opData, opName: 'call_order_update' });
       return tx;
     },
-    limit_order_cancel: (opData) => {
+    limit_order_cancel: (opData: any) => {
       calls.txOps.push({ opData, opName: 'limit_order_cancel' });
       return tx;
     },
-    limit_order_create: (opData) => {
+    limit_order_create: (opData: any) => {
       calls.txOps.push({ opData, opName: 'limit_order_create' });
       return tx;
     },
@@ -235,10 +235,10 @@ function createBroadcastHarness() {
   };
 
   registerMock(bitsharesClientPath, {
-    createAccountClient: (accountName, privateKey) => {
+    createAccountClient: (accountName: any, privateKey: any) => {
       calls.accountClient.push({ accountName, privateKey });
       return {
-        broadcast: async (operation) => {
+        broadcast: async (operation: any) => {
           calls.broadcasts.push(operation);
           return {
             operation,
@@ -256,7 +256,7 @@ function createBroadcastHarness() {
 
   registerMock(credentialClientPath, {
     isCredentialDaemonReady: () => calls.daemonReady,
-    broadcastOperationViaCredentialDaemon: async (accountName, operation, options) => {
+    broadcastOperationViaCredentialDaemon: async (accountName: any, operation: any, options: any) => {
       calls.daemon.broadcast.push({ accountName, operation, options });
       return {
         operation,
@@ -265,7 +265,7 @@ function createBroadcastHarness() {
         source: 'daemon-broadcast'
       };
     },
-    executeOperationsViaCredentialDaemon: async (accountName, operations, options) => {
+    executeOperationsViaCredentialDaemon: async (accountName: any, operations: any, options: any) => {
       calls.daemon.execute.push({ accountName, operations, options });
       return {
         operation_results: [[0, '1.7.77']],
@@ -273,7 +273,7 @@ function createBroadcastHarness() {
         source: 'daemon-execute'
       };
     },
-    waitForCredentialDaemon: async (timeoutMs, options) => {
+    waitForCredentialDaemon: async (timeoutMs: any, options: any) => {
       calls.daemon.wait.push({ options, timeoutMs });
     }
   });
@@ -398,18 +398,18 @@ function createActionsHarness() {
   const dexbotBridgePath = require.resolve('../modules/dexbot_bridge');
 
   const calls = {
-    buildUpdateOrderOp: [],
-    executeOperations: [],
-    resolveAccountId: [],
-    resolveAccountName: [],
-    subscribe: [],
-    unsubscribe: [],
-    getAsset: [],
-    getBackingAsset: [],
-    getFullAccount: [],
-    getOpenOrders: [],
-    getMpaPosition: [],
-    listenCallbacks: []
+    buildUpdateOrderOp: [] as string[],
+    executeOperations: [] as any[],
+    resolveAccountId: [] as string[],
+    resolveAccountName: [] as string[],
+    subscribe: [] as any[],
+    unsubscribe: [] as any[],
+    getAsset: [] as string[],
+    getBackingAsset: [] as string[],
+    getFullAccount: [] as string[],
+    getOpenOrders: [] as string[],
+    getMpaPosition: [] as any[],
+    listenCallbacks: [] as any[]
   };
 
   const assets = {
@@ -443,15 +443,15 @@ function createActionsHarness() {
     ]
   };
 
-  const subscribeHandlers = [];
+  const subscribeHandlers: any[] = [];
 
   registerMock(bitsharesClientPath, {
     BitShares: {
-      subscribe: (topic, callback, accountName) => {
+      subscribe: (topic: any, callback: any, accountName: any) => {
         calls.subscribe.push({ accountName, topic });
         subscribeHandlers.push(callback);
       },
-      unsubscribe: (topic, callback, accountName) => {
+      unsubscribe: (topic: any, callback: any, accountName: any) => {
         calls.unsubscribe.push({ accountName, topic });
         return Promise.resolve();
       }
@@ -459,7 +459,7 @@ function createActionsHarness() {
   });
 
   registerMock(chainBroadcastPath, {
-    executeOperations: async (operations, options) => {
+    executeOperations: async (operations: any, options: any) => {
       calls.executeOperations.push({ options: clone(options), operations: clone(operations) });
       return {
         operation_results: [[0, '1.7.500']],
@@ -469,27 +469,27 @@ function createActionsHarness() {
   });
 
   registerMock(chainQueriesPath, {
-    getAsset: async (symbolOrId) => {
+    getAsset: async (symbolOrId: string) => {
       calls.getAsset.push(symbolOrId);
-      return assets[symbolOrId] || null;
+      return assets[symbolOrId as keyof typeof assets] || null;
     },
-    getBackingAsset: async (symbolOrId) => {
+    getBackingAsset: async (symbolOrId: string) => {
       calls.getBackingAsset.push(symbolOrId);
       return assets.BTS;
     },
-    getFullAccount: async (accountNameOrId) => {
+    getFullAccount: async (accountNameOrId: string) => {
       calls.getFullAccount.push(accountNameOrId);
       return account;
     },
-    readOpenOrders: async (accountNameOrId) => {
+    readOpenOrders: async (accountNameOrId: string) => {
       calls.getOpenOrders.push(accountNameOrId);
       return account.limit_orders;
     },
-    resolveAccountId: async (accountNameOrId) => {
+    resolveAccountId: async (accountNameOrId: string) => {
       calls.resolveAccountId.push(accountNameOrId);
       return accountNameOrId === 'alice' ? '1.2.345' : accountNameOrId;
     },
-    resolveAccountName: async (accountNameOrId) => {
+    resolveAccountName: async (accountNameOrId: string) => {
       calls.resolveAccountName.push(accountNameOrId);
       if (accountNameOrId === '1.2.345') {
         return 'alice';
@@ -503,12 +503,12 @@ function createActionsHarness() {
       FEE_PARAMETERS: { GRAPHENE_COLLATERAL_RATIO_DENOM: 1000 }
     }),
     loadDexbotOrderUtils: () => ({
-      floatToBlockchainInt: (value, precision) => Math.round(Number(value) * (10 ** precision))
+      floatToBlockchainInt: (value: number, precision: number) => Math.round(Number(value) * (10 ** precision))
     }),
-    requireDexbot2Module: (modulePath) => {
+    requireDexbot2Module: (modulePath: string) => {
       calls.buildUpdateOrderOp.push(modulePath);
       return {
-        buildUpdateOrderOp: async (accountName, orderId, newParams, cachedOrder) => ({
+        buildUpdateOrderOp: async (accountName: string, orderId: string, newParams: any, cachedOrder: any) => ({
           op: {
             op_data: {
               accountName,
@@ -645,11 +645,11 @@ async function testChainActions() {
     const mpaPosition = await actions.getMpaPosition('alice', 'HONEST.USD');
     assert.strictEqual(mpaPosition.call_price.quote.asset_id, '1.3.100');
 
-    const received = [];
-    const unsubscribeFirst = await actions.listenForFills('alice', async (fills) => {
+    const received: any[] = [];
+    const unsubscribeFirst = await actions.listenForFills('alice', async (fills: any) => {
       received.push({ fills, source: 'first' });
     });
-    const unsubscribeSecond = await actions.listenForFills('1.2.345', async (fills) => {
+    const unsubscribeSecond = await actions.listenForFills('1.2.345', async (fills: any) => {
       received.push({ fills, source: 'second' });
     });