agentvault 1.0.1 → 1.0.5

package/src/wallet/chain-dispatcher.ts

@@ -1,313 +0,0 @@
-/**
- * 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

@@ -1,346 +0,0 @@
-/**
- * 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);
-}