@financedistrict/fdx 0.1.0

package/src/utils/logger.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3, off: 4 };
+const MAX_BYTES = 5 * 1024 * 1024; // rotate at 5 MB, keep one backup
+
+class Logger {
+  constructor(opts = {}) {
+    this._logPathOverride = opts.logPath || null;
+    this._levelOverride = opts.level || null;
+    this._configured = false;
+    this._logPath = null;
+    this._level = LEVELS.info;
+  }
+
+  _configure() {
+    if (this._configured) return;
+    this._configured = true;
+    this._logPath =
+      this._logPathOverride ||
+      process.env.FDX_LOG_PATH ||
+      path.join(os.homedir(), '.fdx', 'fdx.log');
+    const levelStr = (this._levelOverride || process.env.FDX_LOG_LEVEL || 'info').toLowerCase();
+    this._level = LEVELS[levelStr] ?? LEVELS.info;
+  }
+
+  _write(level, message, data) {
+    this._configure();
+    if (LEVELS[level] < this._level) return;
+
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      level,
+      msg: message,
+      ...(data != null ? { data } : {}),
+    });
+
+    try {
+      this._maybeRotate();
+      fs.mkdirSync(path.dirname(this._logPath), { recursive: true });
+      fs.appendFileSync(this._logPath, line + '\n', { encoding: 'utf8' });
+    } catch {
+      // Logging must never crash the application
+    }
+  }
+
+  _maybeRotate() {
+    try {
+      const stat = fs.statSync(this._logPath);
+      if (stat.size >= MAX_BYTES) {
+        const backup = this._logPath + '.1';
+        try {
+          fs.unlinkSync(backup);
+        } catch {
+          // no existing backup — ignore
+        }
+        fs.renameSync(this._logPath, backup);
+      }
+    } catch {
+      // file may not exist yet — that is fine
+    }
+  }
+
+  debug(message, data) {
+    this._write('debug', message, data);
+  }
+  info(message, data) {
+    this._write('info', message, data);
+  }
+  warn(message, data) {
+    this._write('warn', message, data);
+  }
+  error(message, data) {
+    this._write('error', message, data);
+  }
+}
+
+// Singleton for production use; Logger class exported for testing
+const logger = new Logger();
+logger.Logger = Logger;
+
+module.exports = logger;

package/src/utils/pkce.js

@@ -0,0 +1,27 @@
+const crypto = require('crypto');
+
+function base64UrlEncode(buffer) {
+  return buffer.toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+function generateCodeVerifier(length) {
+  const size = length || 64;
+  const bounded = Math.max(43, Math.min(size, 128));
+  return base64UrlEncode(crypto.randomBytes(bounded));
+}
+
+function generateState(length) {
+  const size = length || 24;
+  return base64UrlEncode(crypto.randomBytes(size));
+}
+
+async function generateCodeChallenge(codeVerifier) {
+  const hash = crypto.createHash('sha256').update(codeVerifier).digest();
+  return base64UrlEncode(hash);
+}
+
+module.exports = {
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+};

package/src/wallet-client.js

@@ -0,0 +1,275 @@
+const { MCPAuthClient } = require('./mcp-auth');
+const { MCPClient } = require('./mcp-client');
+
+class WalletClient {
+  constructor({ mcpServerUrl, redirectUri, storePath, httpClient }) {
+    if (!mcpServerUrl) throw new Error('mcpServerUrl is required');
+    if (!redirectUri) throw new Error('redirectUri is required');
+    if (!storePath) throw new Error('storePath is required');
+
+    this.authClient = new MCPAuthClient({
+      mcpServerUrl,
+      redirectUri,
+      storePath,
+      httpClient,
+    });
+
+    this.mcpClient = new MCPClient({
+      mcpServerUrl,
+      authClient: this.authClient,
+    });
+  }
+
+  async initialize() {
+    return this.authClient.initialize();
+  }
+
+  async initializeForDevice() {
+    return this.authClient.initializeForDevice();
+  }
+
+  async getAuthorizationUrl() {
+    return this.authClient.getAuthorizationUrl();
+  }
+
+  async startDeviceFlow() {
+    return this.authClient.startDeviceFlow();
+  }
+
+  async pollDeviceToken({ deviceCode, interval }) {
+    return this.authClient.pollDeviceToken({ deviceCode, interval });
+  }
+
+  async exchangeCodeForToken({ code, state, codeVerifier }) {
+    return this.authClient.exchangeCodeForToken({ code, state, codeVerifier });
+  }
+
+  async getTokenState() {
+    return this.authClient.getTokenState();
+  }
+
+  async logout() {
+    return this.authClient.logout();
+  }
+
+  async listTools() {
+    return this.mcpClient.listTools();
+  }
+
+  async close() {
+    return this.mcpClient.close();
+  }
+
+  async getMyInfo() {
+    return this.mcpClient.callTool('getMyInfo', {});
+  }
+
+  async getAppVersion() {
+    return this.mcpClient.callTool('getAppVersion', {});
+  }
+
+  async helpNarrative({ question, locale, tone }) {
+    if (!question) throw new Error('question is required');
+
+    return this.mcpClient.callTool('helpNarrative', {
+      question,
+      locale,
+      tone,
+    });
+  }
+
+  async onboardingAssistant({ question, context, locale, tone }) {
+    if (!question) throw new Error('question is required');
+
+    return this.mcpClient.callTool('onboardingAssistant', {
+      question,
+      context,
+      locale,
+      tone,
+    });
+  }
+
+  async reportIssue({ title, description, severity, category }) {
+    if (!title) throw new Error('title is required');
+    if (!description) throw new Error('description is required');
+
+    return this.mcpClient.callTool('reportIssue', {
+      title,
+      description,
+      severity,
+      category,
+    });
+  }
+
+  async getWalletOverview({ chainKey, accountAddress }) {
+    return this.mcpClient.callTool('getWalletOverview', {
+      chainKey,
+      accountAddress,
+    });
+  }
+
+  async getAccountActivity({ chainKey, accountAddress, limit, offset }) {
+    return this.mcpClient.callTool('getAccountActivity', {
+      chainKey,
+      accountAddress,
+      limit,
+      offset,
+    });
+  }
+
+  async deploySmartAccount({ chainKey, initialOwners, threshold }) {
+    if (!chainKey) throw new Error('chainKey is required');
+
+    return this.mcpClient.callTool('deploySmartAccount', {
+      chainKey,
+      initialOwners,
+      threshold,
+    });
+  }
+
+  async manageSmartAccountOwnership({
+    chainKey,
+    accountAddress,
+    action,
+    ownerAddress,
+    newThreshold,
+  }) {
+    if (!chainKey) throw new Error('chainKey is required');
+    if (!accountAddress) throw new Error('accountAddress is required');
+    if (!action) throw new Error('action is required');
+
+    return this.mcpClient.callTool('manageSmartAccountOwnership', {
+      chainKey,
+      accountAddress,
+      action,
+      ownerAddress,
+      newThreshold,
+    });
+  }
+
+  async transferTokens({
+    chainKey,
+    fromAccountAddress,
+    recipientAddress,
+    amount,
+    tokenAddress,
+    memo,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+  }) {
+    if (!chainKey) throw new Error('chainKey is required');
+    if (!recipientAddress) throw new Error('recipientAddress is required');
+    if (!amount) throw new Error('amount is required');
+
+    return this.mcpClient.callTool('transferTokens', {
+      chainKey,
+      fromAccountAddress,
+      recipientAddress,
+      amount,
+      tokenAddress,
+      memo,
+      maxPriorityFeePerGas,
+      maxFeePerGas,
+    });
+  }
+
+  async swapTokens({
+    chainKey,
+    tokenIn,
+    tokenOut,
+    amount,
+    mode,
+    objective,
+    maxSlippageBps,
+    deadlineSeconds,
+  }) {
+    if (!chainKey) throw new Error('chainKey is required');
+    if (!tokenIn) throw new Error('tokenIn is required');
+    if (!tokenOut) throw new Error('tokenOut is required');
+    if (!amount) throw new Error('amount is required');
+
+    return this.mcpClient.callTool('swapTokens', {
+      chainKey,
+      tokenIn,
+      tokenOut,
+      amount,
+      mode,
+      objective,
+      maxSlippageBps,
+      deadlineSeconds,
+    });
+  }
+
+  async discoverYieldStrategies({ chainKey, tokenAddress, minApy, maxRisk, sortBy }) {
+    return this.mcpClient.callTool('discoverYieldStrategies', {
+      chainKey,
+      tokenAddress,
+      minApy,
+      maxRisk,
+      sortBy,
+    });
+  }
+
+  async depositForYield({ chainKey, strategyId, amount, tokenAddress }) {
+    if (!chainKey) throw new Error('chainKey is required');
+    if (!strategyId) throw new Error('strategyId is required');
+    if (!amount) throw new Error('amount is required');
+
+    return this.mcpClient.callTool('depositForYield', {
+      chainKey,
+      strategyId,
+      amount,
+      tokenAddress,
+    });
+  }
+
+  async withdrawFromYield({ chainKey, positionId, amount, recipient }) {
+    if (!chainKey) throw new Error('chainKey is required');
+    if (!positionId) throw new Error('positionId is required');
+
+    return this.mcpClient.callTool('withdrawFromYield', {
+      chainKey,
+      positionId,
+      amount,
+      recipient,
+    });
+  }
+
+  async authorizePayment({
+    url,
+    preferredNetwork,
+    preferredNetworkName,
+    preferredAsset,
+    maxPaymentAmount,
+  }) {
+    if (!url) throw new Error('url is required');
+
+    return this.mcpClient.callTool('authorizePayment', {
+      url,
+      preferredNetwork,
+      preferredNetworkName,
+      preferredAsset,
+      maxPaymentAmount,
+    });
+  }
+
+  async getX402Content({
+    url,
+    preferredNetwork,
+    preferredNetworkName,
+    preferredAsset,
+    maxPaymentAmount,
+  }) {
+    if (!url) throw new Error('url is required');
+
+    return this.mcpClient.callTool('getX402Content', {
+      url,
+      preferredNetwork,
+      preferredNetworkName,
+      preferredAsset,
+      maxPaymentAmount,
+    });
+  }
+}
+
+module.exports = { WalletClient };