agentvault 1.0.0

package/src/wallet/chain-dispatcher.ts

@@ -0,0 +1,313 @@
+/**
+ * Chain Dispatcher (Phase 5C)
+ *
+ * Routes transactions to appropriate blockchain providers.
+ * Supports ckETH, Polkadot, and Solana chains.
+ */
+
+import type { WalletData, TransactionRequest, Transaction, ChainType } from './types.js';
+import { CkEthProvider } from './providers/cketh-provider.js';
+import { PolkadotProvider } from './providers/polkadot-provider.js';
+import { SolanaProvider } from './providers/solana-provider.js';
+
+/**
+ * Chain dispatcher configuration
+ */
+export interface ChainDispatcherConfig {
+  isTestnet?: boolean;
+  apiKey?: string;
+}
+
+/**
+ * Chain dispatcher
+ *
+ * Routes transactions to appropriate blockchain providers based on wallet chain.
+ */
+export class ChainDispatcher {
+  private providers: Map<ChainType, any>;
+  private config: ChainDispatcherConfig;
+
+  constructor(config: ChainDispatcherConfig = {}) {
+    this.config = {
+      isTestnet: config.isTestnet ?? false,
+      apiKey: config.apiKey,
+    };
+
+    this.providers = new Map();
+
+    this.providers.set('cketh', new CkEthProvider({
+      chain: 'cketh',
+      rpcUrl: '',
+      isTestnet: this.config.isTestnet,
+    }));
+
+    this.providers.set('polkadot', new PolkadotProvider({
+      chain: 'polkadot',
+      rpcUrl: '',
+      isTestnet: this.config.isTestnet,
+    }));
+
+    this.providers.set('solana', new SolanaProvider({
+      chain: 'solana',
+      rpcUrl: '',
+      isTestnet: this.config.isTestnet,
+    }));
+  }
+
+  /**
+   * Dispatch transaction to appropriate provider
+   *
+   * @param wallet - Wallet to use for signing
+   * @param request - Transaction request
+   * @returns Transaction result
+   */
+  async dispatchTransaction(
+    wallet: WalletData,
+    request: TransactionRequest
+  ): Promise<Transaction> {
+    const provider = this.getProvider(wallet.chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${wallet.chain}`);
+    }
+
+    await provider.connect();
+
+    const tx = await provider.sendTransaction(wallet.address, request);
+
+    return {
+      hash: tx.hash,
+      from: wallet.address,
+      to: request.to,
+      amount: request.amount,
+      chain: wallet.chain,
+      timestamp: Date.now(),
+      status: 'pending',
+      fee: tx.fee,
+    };
+  }
+
+  /**
+   * Sign transaction without broadcasting
+   *
+   * @param wallet - Wallet to use for signing
+   * @param request - Transaction request
+   * @returns Signed transaction
+   */
+  async signTransaction(
+    wallet: WalletData,
+    request: TransactionRequest
+  ): Promise<{ signedTx: string; signature: string }> {
+    const provider = this.getProvider(wallet.chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${wallet.chain}`);
+    }
+
+    await provider.connect();
+
+    const signed = await provider.signTransaction(request, wallet.privateKey);
+
+    return {
+      signedTx: signed.signedTx,
+      signature: signed.signature || '',
+    };
+  }
+
+  /**
+   * Get wallet balance
+   *
+   * @param wallet - Wallet to query
+   * @returns Wallet balance
+   */
+  async getBalance(wallet: WalletData): Promise<{ amount: string; denomination: string }> {
+    const provider = this.getProvider(wallet.chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${wallet.chain}`);
+    }
+
+    await provider.connect();
+
+    const balance = await provider.getBalance(wallet.address);
+
+    return {
+      amount: balance.amount,
+      denomination: balance.denomination,
+    };
+  }
+
+  /**
+   * Get transaction history
+   *
+   * @param wallet - Wallet to query
+   * @param limit - Maximum number of transactions
+   * @returns Transaction history
+   */
+  async getTransactionHistory(
+    wallet: WalletData,
+    limit: number = 20
+  ): Promise<Transaction[]> {
+    const provider = this.getProvider(wallet.chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${wallet.chain}`);
+    }
+
+    await provider.connect();
+
+    const history = await provider.getTransactionHistory(wallet.address);
+
+    return history.slice(0, limit);
+  }
+
+  /**
+   * Estimate transaction fee
+   *
+   * @param wallet - Wallet to use
+   * @param request - Transaction request
+   * @returns Estimated fee
+   */
+  async estimateFee(
+    wallet: WalletData,
+    request: TransactionRequest
+  ): Promise<string> {
+    const provider = this.getProvider(wallet.chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${wallet.chain}`);
+    }
+
+    await provider.connect();
+
+    const fee = await provider.estimateFee(request);
+
+    return fee;
+  }
+
+  /**
+   * Validate address
+   *
+   * @param address - Address to validate
+   * @param chain - Chain to validate against
+   * @returns True if valid
+   */
+  async validateAddress(address: string, chain: ChainType): Promise<boolean> {
+    const provider = this.getProvider(chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${chain}`);
+    }
+
+    return await provider.validateAddress(address);
+  }
+
+  /**
+   * Get current block number
+   *
+   * @param chain - Chain to query
+   * @returns Current block number
+   */
+  async getBlockNumber(chain: ChainType): Promise<number> {
+    const provider = this.getProvider(chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${chain}`);
+    }
+
+    await provider.connect();
+
+    const block = await provider.getBlockNumber();
+
+    return block;
+  }
+
+  /**
+   * Get transaction by hash
+   *
+   * @param chain - Chain to query
+   * @param txHash - Transaction hash
+   * @returns Transaction details
+   */
+  async getTransaction(chain: ChainType, txHash: string): Promise<Transaction | null> {
+    const provider = this.getProvider(chain);
+
+    if (!provider) {
+      throw new Error(`Unsupported chain: ${chain}`);
+    }
+
+    await provider.connect();
+
+    const tx = await provider.getTransaction(txHash);
+
+    if (!tx) {
+      return null;
+    }
+
+    return {
+      hash: tx.hash,
+      from: tx.from,
+      to: tx.to,
+      amount: tx.amount,
+      chain,
+      timestamp: tx.timestamp,
+      status: tx.status,
+      fee: tx.fee,
+    };
+  }
+
+  /**
+   * Get provider for chain
+   */
+  private getProvider(chain: ChainType): any {
+    const provider = this.providers.get(chain);
+
+    if (!provider) {
+      throw new Error(`No provider found for chain: ${chain}`);
+    }
+
+    return provider;
+  }
+
+  /**
+   * Connect all providers
+   */
+  async connectAll(): Promise<void> {
+    const connections = Array.from(this.providers.entries()).map(async ([chain, provider]) => {
+      try {
+        await provider.connect();
+        return { chain, success: true };
+      } catch (error) {
+        return { chain, success: false, error };
+      }
+    });
+
+    await Promise.all(connections);
+  }
+
+  /**
+   * Disconnect all providers
+   */
+  async disconnectAll(): Promise<void> {
+    const disconnections = Array.from(this.providers.entries()).map(async ([chain, provider]) => {
+      try {
+        await provider.disconnect();
+        return { chain, success: true };
+      } catch (error) {
+        return { chain, success: false, error };
+      }
+    });
+
+    await Promise.all(disconnections);
+  }
+}
+
+/**
+ * Create chain dispatcher
+ *
+ * @param config - Dispatcher configuration
+ * @returns Chain dispatcher instance
+ */
+export function createChainDispatcher(config?: ChainDispatcherConfig): ChainDispatcher {
+  return new ChainDispatcher(config);
+}

package/src/wallet/cross-chain-aggregator.ts

@@ -0,0 +1,346 @@
+/**
+ * Cross-Chain Aggregator (Phase 5C)
+ *
+ * Executes multiple blockchain transactions in parallel.
+ * Supports independent execution (no atomic rollback) as per user preference.
+ */
+
+import type { WalletData, TransactionRequest, Transaction, ChainType } from './types.js';
+import { ChainDispatcher } from './chain-dispatcher.js';
+
+/**
+ * Multi-chain action
+ */
+export interface MultiChainAction {
+  walletId: string;
+  chain: ChainType;
+  request: TransactionRequest;
+  priority?: 'low' | 'normal' | 'high';
+}
+
+/**
+ * Cross-chain execution result
+ */
+export interface CrossChainResult {
+  action: MultiChainAction;
+  success: boolean;
+  txHash?: string;
+  error?: string;
+  executedAt: number;
+  duration?: number;
+}
+
+/**
+ * Aggregated execution results
+ */
+export interface AggregatedResults {
+  total: number;
+  succeeded: number;
+  failed: number;
+  results: CrossChainResult[];
+  duration: number;
+}
+
+/**
+ * Cross-chain aggregator options
+ */
+export interface AggregatorOptions {
+  maxConcurrency?: number;
+  timeout?: number;
+  continueOnError?: boolean;
+}
+
+/**
+ * Cross-chain aggregator
+ *
+ * Executes transactions across multiple blockchains in parallel.
+ * Independent execution: No rollback on partial failure.
+ */
+export class CrossChainAggregator {
+  private dispatcher: ChainDispatcher;
+  private options: AggregatorOptions;
+
+  constructor(options?: AggregatorOptions) {
+    this.dispatcher = new ChainDispatcher();
+    this.options = {
+      maxConcurrency: options?.maxConcurrency ?? 5,
+      timeout: options?.timeout ?? 30000,
+      continueOnError: options?.continueOnError ?? true,
+    };
+  }
+
+  /**
+   * Execute multiple cross-chain actions
+   *
+   * @param actions - Array of multi-chain actions
+   * @returns Aggregated results
+   */
+  async execute(actions: MultiChainAction[]): Promise<AggregatedResults> {
+    const startTime = Date.now();
+
+    if (actions.length === 0) {
+      return {
+        total: 0,
+        succeeded: 0,
+        failed: 0,
+        results: [],
+        duration: 0,
+      };
+    }
+
+    console.log(`Executing ${actions.length} cross-chain actions...`);
+
+    const results = await this.executeParallel(actions);
+
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+
+    const duration = Date.now() - startTime;
+
+    console.log(
+      `Execution complete: ${succeeded} succeeded, ${failed} failed (${duration}ms)`
+    );
+
+    return {
+      total: results.length,
+      succeeded,
+      failed,
+      results,
+      duration,
+    };
+  }
+
+  /**
+   * Execute actions in parallel with concurrency limit
+   */
+  private async executeParallel(
+    actions: MultiChainAction[]
+  ): Promise<CrossChainResult[]> {
+    const results: CrossChainResult[] = [];
+
+    const chunks = this.chunkArray(
+      actions,
+      this.options.maxConcurrency ?? 5
+    );
+
+    for (const chunk of chunks) {
+      const chunkResults = await Promise.all(
+        chunk.map((action) => this.executeAction(action))
+      );
+
+      results.push(...chunkResults);
+
+      if (!this.options.continueOnError) {
+        const hasFailure = chunkResults.some((r) => !r.success);
+        if (hasFailure) {
+          console.log('Stopping due to failure (continueOnError = false)');
+          break;
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Execute a single cross-chain action
+   */
+  private async executeAction(
+    action: MultiChainAction
+  ): Promise<CrossChainResult> {
+    const startTime = Date.now();
+
+    try {
+      const { getWallet } = await import('./wallet-manager.js');
+      const wallet = getWallet('', action.walletId);
+
+      if (!wallet) {
+        throw new Error(`Wallet not found: ${action.walletId}`);
+      }
+
+      const tx = await this.dispatcher.dispatchTransaction(
+        wallet,
+        action.request
+      );
+
+      const duration = Date.now() - startTime;
+
+      return {
+        action,
+        success: true,
+        txHash: tx.hash,
+        executedAt: Date.now(),
+        duration,
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const message = error instanceof Error ? error.message : 'Unknown error';
+
+      return {
+        action,
+        success: false,
+        error: message,
+        executedAt: Date.now(),
+        duration,
+      };
+    }
+  }
+
+  /**
+   * Split array into chunks
+   */
+  private chunkArray<T>(array: T[], size: number): T[][] {
+    const chunks: T[][] = [];
+
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+
+    return chunks;
+  }
+
+  /**
+   * Get balances across multiple chains
+   *
+   * @param wallets - Array of wallets to query
+   * @returns Array of balances
+   */
+  async getBalances(
+    wallets: WalletData[]
+  ): Promise<Array<{ wallet: WalletData; amount: string; denomination: string }>> {
+    const results = await Promise.all(
+      wallets.map(async (wallet) => {
+        try {
+          const balance = await this.dispatcher.getBalance(wallet);
+          return {
+            wallet,
+            amount: balance.amount,
+            denomination: balance.denomination,
+            success: true,
+          };
+        } catch (error) {
+          return {
+            wallet,
+            amount: '0',
+            denomination: 'N/A',
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          };
+        }
+      })
+    );
+
+    return results;
+  }
+
+  /**
+   * Get transaction history across multiple chains
+   *
+   * @param wallets - Array of wallets to query
+   * @param limit - Maximum transactions per wallet
+   * @returns Array of transactions
+   */
+  async getMultiChainHistory(
+    wallets: WalletData[],
+    limit: number = 20
+  ): Promise<Transaction[]> {
+    const results = await Promise.all(
+      wallets.map(async (wallet) => {
+        try {
+          return await this.dispatcher.getTransactionHistory(wallet, limit);
+        } catch (error) {
+          console.error(
+            `Failed to get history for ${wallet.id}:`,
+            error
+          );
+          return [];
+        }
+      })
+    );
+
+    return results.flat().slice(0, wallets.length * limit);
+  }
+
+  /**
+   * Estimate fees across multiple chains
+   *
+   * @param actions - Array of actions to estimate
+   * @returns Array of fee estimates
+   */
+  async estimateFees(
+    actions: MultiChainAction[]
+  ): Promise<Array<{ action: MultiChainAction; fee: string }>> {
+    const results = await Promise.all(
+      actions.map(async (action) => {
+        try {
+          const { getWallet } = await import('./wallet-manager.js');
+          const wallet = getWallet('', action.walletId);
+
+          if (!wallet) {
+            throw new Error(`Wallet not found: ${action.walletId}`);
+          }
+
+          const fee = await this.dispatcher.estimateFee(wallet, action.request);
+
+          return {
+            action,
+            fee,
+            success: true,
+          };
+        } catch (error) {
+          return {
+            action,
+            fee: 'N/A',
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          };
+        }
+      })
+    );
+
+    return results;
+  }
+
+  /**
+   * Create cross-chain batch summary
+   *
+   * @param results - Aggregated execution results
+   * @returns Formatted summary
+   */
+  createSummary(results: AggregatedResults): string {
+    const lines: string[] = [];
+
+    lines.push('Cross-Chain Execution Summary');
+    lines.push('============================');
+    lines.push(`Total Actions:    ${results.total}`);
+    lines.push(`Succeeded:         ${results.succeeded}`);
+    lines.push(`Failed:            ${results.failed}`);
+    lines.push(`Success Rate:      ${results.total > 0 ? ((results.succeeded / results.total) * 100).toFixed(2) : 0}%`);
+    lines.push(`Total Duration:    ${results.duration}ms`);
+
+    if (results.failed > 0) {
+      lines.push('');
+      lines.push('Failed Actions:');
+      results.results
+        .filter((r) => !r.success)
+        .forEach((r) => {
+          lines.push(`  [${r.action.chain}] ${r.action.walletId}`);
+          lines.push(`    Error: ${r.error}`);
+        });
+    }
+
+    return lines.join('\n');
+  }
+}
+
+/**
+ * Create cross-chain aggregator
+ *
+ * @param options - Aggregator options
+ * @returns Cross-chain aggregator instance
+ */
+export function createCrossChainAggregator(
+  options?: AggregatorOptions
+): CrossChainAggregator {
+  return new CrossChainAggregator(options);
+}