dexbot 1.4.12 → 1.4.13

package/claw/modules/chain_broadcast.ts

@@ -0,0 +1,353 @@
+
+import * as client from './bitshares_client.js';
+const { createAccountClient } = client;
+import { path } from '../../modules/path_api.js';
+import { getStorage } from '../../modules/storage/index.js';
+import { getDexbot2Root, requireDexbot2Module } from './dexbot_bridge.js';
+import { Config } from '../../modules/config.js';
+import { DAEMON_ERRORS } from '../../modules/constants.js';
+import { getCredentialReadyFilePath } from '../../modules/credential_runtime.js';
+import { runtime } from '../../modules/runtime.js';
+const storage = getStorage();
+const { readJSON } = storage;
+import { isCredentialDaemonReady, DEFAULT_BROADCAST_TIMEOUT_MS, broadcastOperationViaCredentialDaemon, executeOperationsViaCredentialDaemon, waitForCredentialDaemon, BroadcastUncertainError } from './dexbot_credential_client.js';
+import { getErrorMessage } from '../../modules/utils/errors.js';
+
+// Lazy-load DEXBot2 modules
+let chainKeys: any = null;
+let credentialPolicy: any = null;
+let broadcastFailureClassifier: any = null;
+
+function getChainKeys() {
+  if (!chainKeys) chainKeys = requireDexbot2Module('modules/chain_keys.js');
+  return chainKeys;
+}
+
+function getCredentialPolicy() {
+  if (!credentialPolicy) credentialPolicy = requireDexbot2Module('modules/credential_policy.js');
+  return credentialPolicy;
+}
+
+function getBroadcastFailureClassifier() {
+  if (!broadcastFailureClassifier) {
+    const mod = requireDexbot2Module('modules/broadcast_failure.js');
+    broadcastFailureClassifier = (mod && typeof mod.classifyBroadcastFailure === 'function')
+      ? mod.classifyBroadcastFailure
+      : (mod && typeof mod.default === 'function' ? mod.default : null);
+  }
+  return broadcastFailureClassifier;
+}
+
+/**
+ * Classify a direct-key broadcast failure so callers never blindly re-issue
+ * an operation whose broadcast may have landed. Mirrors the credential-daemon
+ * classification: 'uncertain' becomes a typed BroadcastUncertainError (the
+ * same type the daemon path produces), 'retryable'/'definite' propagate as-is.
+ * @param {Error} err - The raw broadcast error
+ * @param {Array} ops - The operations that were broadcast
+ * @param {string|null} accountName - Account the broadcast was for
+ * @param {Object} options - Broadcast options (batchId etc.)
+ * @returns {Error} The classified error to throw
+ */
+function classifyClawBroadcastError(err: any, ops: any[], accountName: string | null, options: Record<string, any> = {}) {
+  try {
+    const classifier = getBroadcastFailureClassifier();
+    if (classifier && classifier(err) === 'uncertain') {
+      return new BroadcastUncertainError(
+        `Claw direct-key broadcast uncertain (may have landed): ${getErrorMessage(err)}`,
+        {
+          operations: ops,
+          accountName,
+          batchId: options.batchId || null,
+          payload: null,
+          timeoutMs: null,
+        }
+      );
+    }
+  } catch (_) {
+    // Classification is best-effort — fall through to the original error.
+  }
+  return err;
+}
+
+function _sendSighupToDaemon() {
+  try {
+    const root = getDexbot2Root();
+    const readyFile = getCredentialReadyFilePath({ root });
+    if (storage.exists(readyFile)) {
+      const daemonInfo = readJSON(readyFile);
+      if (daemonInfo && typeof daemonInfo.pid === 'number') {
+        runtime.kill(daemonInfo.pid, 'SIGHUP');
+        console.log(`[CLAW][credential-daemon] Sent SIGHUP (pid ${daemonInfo.pid}) to reload policy config`);
+      }
+    }
+  } catch (sigErr: any) {
+    console.warn(`[CLAW][credential-daemon] Could not send SIGHUP: ${getErrorMessage(sigErr)}`);
+  }
+}
+
+/**
+ * Resolve sessionId and botHmacSecret for an account.
+ * Probes the daemon for a session and loads the HMAC secret from DEXBot2 profiles.
+ *
+ * @param {string} accountName – BitShares account name
+ * @param {Object} [options]   – Optional sessionId or botHmacSecret overrides
+ * @returns {Promise<{sessionId: string|null, botHmacSecret: string|null}>}
+ */
+async function resolveSessionCredentials(accountName: any, options: Record<string, any> = {}) {
+  let sessionId = options.sessionId || null;
+  let botHmacSecret = options.botHmacSecret || null;
+
+  if (sessionId && botHmacSecret) {
+    return { sessionId, botHmacSecret };
+  }
+
+  try {
+    const chainKeysMod = getChainKeys();
+    const policyMod = getCredentialPolicy();
+
+    // If no sessionId, probe the daemon
+    if (!sessionId) {
+      sessionId = await chainKeysMod.probeAccountInDaemon(accountName, 5000, options);
+    }
+
+    // If no secret, try to load it from DEXBot2 profile
+    if (!botHmacSecret) {
+      const policyPath = path.join(getDexbot2Root(), 'profiles', 'daemon-policies.json');
+      botHmacSecret = policyMod.loadBotHmacSecret(accountName, policyPath);
+    }
+  } catch (err: any) {
+    console.warn(`[CLAW] Failed to resolve session credentials: ${getErrorMessage(err)}`);
+  }
+
+  return { sessionId, botHmacSecret };
+}
+
+async function createSigningClient(accountName: any, privateKey: any) {
+  return createAccountClient(accountName, privateKey);
+}
+
+function resolveAccountName(options: Record<string, any> = {}) {
+  return options.accountName || Config.BITSHARES_ACCOUNT || null;
+}
+
+async function createSigningClientFromCredentialDaemon(options: Record<string, any> = {}) {
+  throw new Error(
+    'The credential daemon no longer exports raw private keys. ' +
+    'Use broadcastOperationViaCredentialDaemon() or executeOperationsViaCredentialDaemon() ' +
+    'to have the daemon sign and broadcast operations directly.'
+  );
+}
+
+async function getSigningClient(options: Record<string, any> = {}) {
+  const accountName = resolveAccountName(options);
+  if (!accountName) {
+    throw new Error('accountName is required');
+  }
+
+  if (options.privateKey) {
+    return createSigningClient(accountName, options.privateKey);
+  }
+
+  if (!isCredentialDaemonReady(options)) {
+    throw new Error('Credential daemon is not ready');
+  }
+
+  return createSigningClientFromCredentialDaemon({
+    ...options,
+    accountName
+  });
+}
+
+function normalizeOperations(operations: any) {
+  const ops = Array.isArray(operations) ? operations : [operations];
+  return ops.filter(Boolean);
+}
+
+async function executeOperations(operations: any, options: Record<string, any> = {}) {
+  const ops = normalizeOperations(operations);
+  if (ops.length === 0) {
+    return { success: true, operation_results: [], raw: null };
+  }
+
+  if (!options.privateKey && isCredentialDaemonReady(options)) {
+    const accountName = resolveAccountName(options);
+    if (!accountName) {
+      throw new Error('accountName is required');
+    }
+
+    const daemonTimeoutMs = Number.isFinite(Number(options.daemonTimeoutMs))
+      ? Number(options.daemonTimeoutMs)
+      : undefined;
+    // Clamp the broadcast request timeout up to the default outer window: the
+    // daemon's inner deadline (25s) must be allowed to fire and reply a typed
+    // BROADCAST_DEADLINE before this socket timer. A caller-supplied short
+    // timeout would time out mid-broadcast — a false uncertain.
+    const requestTimeoutMs = Number.isFinite(Number(options.daemonRequestTimeoutMs))
+      ? Math.max(Number(options.daemonRequestTimeoutMs), DEFAULT_BROADCAST_TIMEOUT_MS)
+      : undefined;
+
+    await waitForCredentialDaemon(daemonTimeoutMs, options);
+
+    let { sessionId, botHmacSecret } = await resolveSessionCredentials(accountName, options);
+
+    try {
+      const result = await executeOperationsViaCredentialDaemon(accountName, ops, {
+        socketPath: options.socketPath,
+        timeoutMs: requestTimeoutMs,
+        sessionId,
+        botHmacSecret,
+        requestType: 'broadcast',
+        batchId: options.batchId || null
+      });
+
+      return {
+        ...result,
+        operation_results: result.operation_results || [],
+        raw: result.raw || null,
+        success: true
+      };
+    } catch (err: any) {
+      const msg = String(getErrorMessage(err) || err);
+      if (msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED) || msg.includes(DAEMON_ERRORS.SESSION_EXPIRED)) {
+        const isSourceAuthError = msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED);
+        console.warn(`[CLAW] Session/HMAC error, re-resolving credentials and retrying: ${msg}`);
+        if (isSourceAuthError) {
+          _sendSighupToDaemon();
+        }
+        const retry = await resolveSessionCredentials(accountName, options);
+        if (isSourceAuthError) {
+          await new Promise(r => setTimeout(r, 500));
+        }
+        const result = await executeOperationsViaCredentialDaemon(accountName, ops, {
+          socketPath: options.socketPath,
+          timeoutMs: requestTimeoutMs,
+          sessionId: retry.sessionId,
+          botHmacSecret: retry.botHmacSecret,
+          requestType: 'broadcast',
+          batchId: options.batchId || null
+        });
+        return {
+          ...result,
+          operation_results: result.operation_results || [],
+          raw: result.raw || null,
+          success: true
+        };
+      }
+      throw err;
+    }
+  }
+
+  const client = await getSigningClient(options);
+  if (client.initPromise) {
+    await client.initPromise;
+  }
+
+  if (typeof client.newTx !== 'function') {
+    throw new Error('Signing client does not support newTx()');
+  }
+
+  const tx = client.newTx();
+  for (const op of ops) {
+    if (!op.op_name || !op.op_data) {
+      throw new Error('Each operation requires op_name and op_data');
+    }
+    if (typeof tx[op.op_name] !== 'function') {
+      throw new Error(`Transaction builder does not support ${op.op_name}`);
+    }
+    tx[op.op_name](op.op_data);
+  }
+
+  // Direct-key broadcasts must be classified: a timeout/drop here surfaces as
+  // a plain Error unless wrapped, inviting callers to blindly re-issue the
+  // operations (duplicate orders). 'uncertain' maps to BroadcastUncertainError.
+  let result: any;
+  try {
+    result = await tx.broadcast();
+  } catch (err: any) {
+    throw classifyClawBroadcastError(err, ops, resolveAccountName(options), options);
+  }
+  const operationResults =
+    (result && Array.isArray(result.operation_results) && result.operation_results) ||
+    (result && result.trx && Array.isArray(result.trx.operation_results) && result.trx.operation_results) ||
+    (Array.isArray(result) && result[0] && result[0].trx && Array.isArray(result[0].trx.operation_results) && result[0].trx.operation_results) ||
+    [];
+
+  return {
+    success: true,
+    raw: result,
+    operation_results: operationResults
+  };
+}
+
+async function broadcastOperation(operation: any, options: Record<string, any> = {}) {
+  if (operation && operation.op_name && operation.op_data) {
+    return executeOperations([operation], options);
+  }
+
+  if (!options.privateKey && isCredentialDaemonReady(options)) {
+    const accountName = resolveAccountName(options);
+    if (!accountName) {
+      throw new Error('accountName is required');
+    }
+
+    const daemonTimeoutMs = Number.isFinite(Number(options.daemonTimeoutMs))
+      ? Number(options.daemonTimeoutMs)
+      : undefined;
+    // Clamp the broadcast request timeout up to the default outer window: the
+    // daemon's inner deadline (25s) must be allowed to fire and reply a typed
+    // BROADCAST_DEADLINE before this socket timer. A caller-supplied short
+    // timeout would time out mid-broadcast — a false uncertain.
+    const requestTimeoutMs = Number.isFinite(Number(options.daemonRequestTimeoutMs))
+      ? Math.max(Number(options.daemonRequestTimeoutMs), DEFAULT_BROADCAST_TIMEOUT_MS)
+      : undefined;
+
+    await waitForCredentialDaemon(daemonTimeoutMs, options);
+
+    let { sessionId, botHmacSecret } = await resolveSessionCredentials(accountName, options);
+
+    async function doBroadcast(sid: string | null | undefined, secret: string | null) {
+      const result = await broadcastOperationViaCredentialDaemon(accountName, operation, {
+        socketPath: options.socketPath,
+        timeoutMs: requestTimeoutMs,
+        sessionId: sid,
+        botHmacSecret: secret
+      });
+      const operationResults =
+        (result && Array.isArray(result.operation_results) && result.operation_results) ||
+        (result && result.trx && Array.isArray(result.trx.operation_results) && result.trx.operation_results) ||
+        (Array.isArray(result) && result[0] && result[0].trx && Array.isArray(result[0].trx.operation_results) && result[0].trx.operation_results) ||
+        [];
+      return { success: true, raw: result, operation_results: operationResults };
+    }
+
+    try {
+      return await doBroadcast(sessionId, botHmacSecret);
+    } catch (err: any) {
+      const msg = String(getErrorMessage(err) || err);
+      if (msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED) || msg.includes(DAEMON_ERRORS.SESSION_EXPIRED)) {
+        const isSourceAuthError = msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED);
+        console.warn(`[CLAW] Session/HMAC error, re-resolving credentials and retrying: ${msg}`);
+        if (isSourceAuthError) {
+          _sendSighupToDaemon();
+        }
+        const retry = await resolveSessionCredentials(accountName, options);
+        if (isSourceAuthError) {
+          await new Promise(r => setTimeout(r, 500));
+        }
+        return await doBroadcast(retry.sessionId, retry.botHmacSecret);
+      }
+      throw err;
+    }
+  }
+
+  const client = await getSigningClient(options);
+  try {
+    return await client.broadcast(operation);
+  } catch (err: any) {
+    throw classifyClawBroadcastError(err, [operation], resolveAccountName(options), options);
+  }
+}
+
+export { broadcastOperation, createSigningClient, createSigningClientFromCredentialDaemon, executeOperations, getSigningClient, resolveAccountName }
+

package/claw/modules/chain_queries.ts

@@ -0,0 +1,157 @@
+
+
+import * as client from './bitshares_client.js';
+const { BitShares, waitForConnected } = client;
+import { loadDexbotOrderSystemUtils, loadDexbotOrderUtils } from './dexbot_bridge.js';
+function getDexbotSystem() {
+  return loadDexbotOrderSystemUtils();
+}
+
+function getBlockchainToFloat() {
+  return loadDexbotOrderUtils().blockchainToFloat;
+}
+
+async function dbCall(method: any, args: any[] = []) {
+  await waitForConnected();
+
+  if (BitShares?.db && typeof BitShares.db[method] === 'function') {
+    return BitShares.db[method](...args);
+  }
+
+  if (BitShares?.db && typeof BitShares.db.call === 'function') {
+    return BitShares.db.call(method, args);
+  }
+
+  throw new Error(`BitShares database method not available: ${method}`);
+}
+
+function toAssetMap(assetList: any[] = []) {
+  const assetMap = new Map();
+  for (const asset of assetList) {
+    if (asset && asset.id) {
+      assetMap.set(asset.id, asset);
+    }
+  }
+  return assetMap;
+}
+
+async function getDynamicGlobalProperties() {
+  return dbCall('get_dynamic_global_properties');
+}
+
+async function getAsset(symbolOrId: any) {
+  if (/^1\.3\.\d+$/.test(symbolOrId)) {
+    const assets = await dbCall('get_assets', [[symbolOrId]]);
+    return assets[0] || null;
+  }
+
+  try {
+    return await getDexbotSystem().lookupAsset(BitShares, symbolOrId);
+  } catch {
+    const assets = await dbCall('lookup_asset_symbols', [[symbolOrId]]);
+    return assets[0] || null;
+  }
+}
+
+async function getObjects(objectIds: any) {
+  return dbCall('get_objects', [objectIds]);
+}
+
+async function getAssetPrecision(symbolOrId: any) {
+  const asset = await getAsset(symbolOrId);
+  if (!asset || typeof asset.precision !== 'number') {
+    throw new Error(`Could not resolve asset precision for ${symbolOrId}`);
+  }
+  return asset.precision;
+}
+
+async function getBitassetData(symbolOrId: any) {
+  const asset = await getAsset(symbolOrId);
+  if (!asset || !asset.bitasset_data_id) {
+    return null;
+  }
+
+  const objects = await getObjects([asset.bitasset_data_id]);
+  return objects[0] || null;
+}
+
+async function getBackingAsset(symbolOrId: any) {
+  const bitassetData = await getBitassetData(symbolOrId);
+  const backingAssetId = bitassetData?.options?.short_backing_asset;
+
+  if (!backingAssetId) {
+    return null;
+  }
+
+  return getAsset(backingAssetId);
+}
+
+async function getFullAccount(accountNameOrId: any) {
+  const result = await dbCall('get_full_accounts', [[accountNameOrId], false]);
+  return result[0] ? result[0][1] : null;
+}
+
+async function resolveAccountId(accountNameOrId: any) {
+  if (/^1\.2\.\d+$/.test(accountNameOrId)) {
+    return accountNameOrId;
+  }
+
+  const full = await getFullAccount(accountNameOrId);
+  return full && full.account ? full.account.id : null;
+}
+
+async function resolveAccountName(accountNameOrId: any) {
+  if (!/^1\.2\.\d+$/.test(accountNameOrId)) {
+    return accountNameOrId;
+  }
+
+  const full = await getFullAccount(accountNameOrId);
+  return full && full.account ? full.account.name : null;
+}
+
+async function readOpenOrders(accountNameOrId: any) {
+  const full = await getFullAccount(accountNameOrId);
+  return full && Array.isArray(full.limit_orders) ? full.limit_orders : [];
+}
+
+async function getBalances(accountNameOrId: any) {
+  const full = await getFullAccount(accountNameOrId);
+  if (!full || !Array.isArray(full.balances) || full.balances.length === 0) {
+    return {};
+  }
+
+  const assetIds = full.balances.map((entry: any) => entry.asset_type).filter(Boolean);
+  const assets = await dbCall('get_assets', [assetIds]);
+  const assetMap = toAssetMap(assets);
+  const blockchainToFloat = getBlockchainToFloat();
+
+  const balances: Record<string, any> = {};
+  for (const balance of full.balances) {
+    const asset = assetMap.get(balance.asset_type);
+    if (!asset) {
+      continue;
+    }
+
+    balances[asset.symbol] = blockchainToFloat(balance.balance, asset.precision);
+  }
+  return balances;
+}
+
+async function getOrderBook(baseSymbol: any, quoteSymbol: any, limit = 10) {
+  return dbCall('get_order_book', [baseSymbol, quoteSymbol, limit]);
+}
+
+async function getTicker(baseSymbol: any, quoteSymbol: any) {
+  return dbCall('get_ticker', [baseSymbol, quoteSymbol]);
+}
+
+async function getCallOrders(assetSymbolOrId: any, limit = 20) {
+  return dbCall('get_call_orders', [assetSymbolOrId, limit]);
+}
+
+async function listAssets(lowerBoundSymbol: any = 'A', limit = 100) {
+  return dbCall('list_assets', [lowerBoundSymbol, limit]);
+}
+
+export { dbCall, getAsset, getBackingAsset, getBitassetData, getAssetPrecision, getBalances, getCallOrders, getDynamicGlobalProperties, getFullAccount, getObjects, getOrderBook, getTicker, listAssets, readOpenOrders, resolveAccountId, resolveAccountName }
+