agentvault 1.0.0 → 1.0.2

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

@@ -0,0 +1,119 @@
+/**
+ * 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';
+/**
+ * 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 declare class CrossChainAggregator {
+    private dispatcher;
+    private options;
+    constructor(options?: AggregatorOptions);
+    /**
+     * Execute multiple cross-chain actions
+     *
+     * @param actions - Array of multi-chain actions
+     * @returns Aggregated results
+     */
+    execute(actions: MultiChainAction[]): Promise<AggregatedResults>;
+    /**
+     * Execute actions in parallel with concurrency limit
+     */
+    private executeParallel;
+    /**
+     * Execute a single cross-chain action
+     */
+    private executeAction;
+    /**
+     * Split array into chunks
+     */
+    private chunkArray;
+    /**
+     * Get balances across multiple chains
+     *
+     * @param wallets - Array of wallets to query
+     * @returns Array of balances
+     */
+    getBalances(wallets: WalletData[]): Promise<Array<{
+        wallet: WalletData;
+        amount: string;
+        denomination: string;
+    }>>;
+    /**
+     * Get transaction history across multiple chains
+     *
+     * @param wallets - Array of wallets to query
+     * @param limit - Maximum transactions per wallet
+     * @returns Array of transactions
+     */
+    getMultiChainHistory(wallets: WalletData[], limit?: number): Promise<Transaction[]>;
+    /**
+     * Estimate fees across multiple chains
+     *
+     * @param actions - Array of actions to estimate
+     * @returns Array of fee estimates
+     */
+    estimateFees(actions: MultiChainAction[]): Promise<Array<{
+        action: MultiChainAction;
+        fee: string;
+    }>>;
+    /**
+     * Create cross-chain batch summary
+     *
+     * @param results - Aggregated execution results
+     * @returns Formatted summary
+     */
+    createSummary(results: AggregatedResults): string;
+}
+/**
+ * Create cross-chain aggregator
+ *
+ * @param options - Aggregator options
+ * @returns Cross-chain aggregator instance
+ */
+export declare function createCrossChainAggregator(options?: AggregatorOptions): CrossChainAggregator;
+//# sourceMappingURL=cross-chain-aggregator.d.ts.map

package/dist/src/wallet/cross-chain-aggregator.js

@@ -0,0 +1,235 @@
+/**
+ * Cross-Chain Aggregator (Phase 5C)
+ *
+ * Executes multiple blockchain transactions in parallel.
+ * Supports independent execution (no atomic rollback) as per user preference.
+ */
+import { ChainDispatcher } from './chain-dispatcher.js';
+/**
+ * Cross-chain aggregator
+ *
+ * Executes transactions across multiple blockchains in parallel.
+ * Independent execution: No rollback on partial failure.
+ */
+export class CrossChainAggregator {
+    dispatcher;
+    options;
+    constructor(options) {
+        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) {
+        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
+     */
+    async executeParallel(actions) {
+        const results = [];
+        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
+     */
+    async executeAction(action) {
+        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
+     */
+    chunkArray(array, size) {
+        const chunks = [];
+        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) {
+        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, limit = 20) {
+        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) {
+        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) {
+        const lines = [];
+        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) {
+    return new CrossChainAggregator(options);
+}
+//# sourceMappingURL=cross-chain-aggregator.js.map

package/dist/src/wallet/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Wallet Module
+ *
+ * Complete wallet management system for ckETH, Polkadot, and Solana.
+ * Provides per-agent wallet isolation, encryption, and CBOR serialization.
+ */
+export * from './types.js';
+export { serializeWallet, deserializeWallet, serializeTransaction, deserializeTransaction, serializeTransactionRequest, deserializeTransactionRequest, serializeSignedTransaction, deserializeSignedTransaction, validateCborData, } from './cbor-serializer.js';
+export { getWalletBaseDir, getAgentWalletDir, getWalletFilePath, ensureWalletDirectories, saveWallet, loadWallet, deleteWallet, listWallets, listAgents, walletExists, getWalletStats, backupWallets, restoreWallets, clearWallets, getWalletStorageSize, } from './wallet-storage.js';
+export { parseDerivationPath, buildDerivationPath, validateSeedPhrase, generateSeedFromMnemonic, generateMnemonic, getDefaultDerivationPath, deriveWalletKey, } from './key-derivation.js';
+export { createWallet, importWalletFromPrivateKey, importWalletFromSeed, importWalletFromMnemonic, generateWallet, getWallet, listAgentWallets, hasWallet, removeWallet, clearAgentWallets, cacheWalletConnection, getCachedConnection, clearCachedConnection, validateSeedPhraseWrapper, } from './wallet-manager.js';
+export { BaseWalletProvider } from './providers/base-provider.js';
+export { CkEthProvider } from './providers/cketh-provider.js';
+export { PolkadotProvider } from './providers/polkadot-provider.js';
+export { SolanaProvider } from './providers/solana-provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/wallet/index.js

@@ -0,0 +1,22 @@
+/**
+ * Wallet Module
+ *
+ * Complete wallet management system for ckETH, Polkadot, and Solana.
+ * Provides per-agent wallet isolation, encryption, and CBOR serialization.
+ */
+// Types
+export * from './types.js';
+// CBOR Serialization
+export { serializeWallet, deserializeWallet, serializeTransaction, deserializeTransaction, serializeTransactionRequest, deserializeTransactionRequest, serializeSignedTransaction, deserializeSignedTransaction, validateCborData, } from './cbor-serializer.js';
+// Wallet Storage
+export { getWalletBaseDir, getAgentWalletDir, getWalletFilePath, ensureWalletDirectories, saveWallet, loadWallet, deleteWallet, listWallets, listAgents, walletExists, getWalletStats, backupWallets, restoreWallets, clearWallets, getWalletStorageSize, } from './wallet-storage.js';
+// Key Derivation
+export { parseDerivationPath, buildDerivationPath, validateSeedPhrase, generateSeedFromMnemonic, generateMnemonic, getDefaultDerivationPath, deriveWalletKey, } from './key-derivation.js';
+// Wallet Manager
+export { createWallet, importWalletFromPrivateKey, importWalletFromSeed, importWalletFromMnemonic, generateWallet, getWallet, listAgentWallets, hasWallet, removeWallet, clearAgentWallets, cacheWalletConnection, getCachedConnection, clearCachedConnection, validateSeedPhraseWrapper, } from './wallet-manager.js';
+// Providers
+export { BaseWalletProvider } from './providers/base-provider.js';
+export { CkEthProvider } from './providers/cketh-provider.js';
+export { PolkadotProvider } from './providers/polkadot-provider.js';
+export { SolanaProvider } from './providers/solana-provider.js';
+//# sourceMappingURL=index.js.map

package/dist/src/wallet/key-derivation.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Key Derivation Module
+ *
+ * Implements BIP39 seed phrase derivation for wallet keys.
+ * Supports multiple derivation paths for different blockchains.
+ */
+import type { WalletCreationMethod } from './types.js';
+/**
+ * Derivation path components
+ */
+export interface DerivationPathComponents {
+    /** Purpose (e.g., 44' for BIP44) */
+    purpose: number;
+    /** Coin type (e.g., 60' for ETH, 0' for BTC) */
+    coinType: number;
+    /** Account index */
+    account: number;
+    /** Change index (0 for external, 1 for internal) */
+    change: number;
+    /** Address index */
+    index: number;
+}
+/**
+ * Derived key information
+ */
+export interface DerivedKey {
+    /** Private key (hex) */
+    privateKey: string;
+    /** Public key (hex) */
+    publicKey: string;
+    /** Address (chain-specific format) */
+    address: string;
+    /** Derivation path used */
+    derivationPath: string;
+}
+/**
+ * Parse derivation path string
+ *
+ * @param path - Derivation path string (e.g., "m/44'/60'/0'/0/0")
+ * @returns Parsed path components
+ */
+export declare function parseDerivationPath(path: string): DerivationPathComponents;
+/**
+ * Build derivation path from components
+ *
+ * @param components - Path components
+ * @returns Derivation path string
+ */
+export declare function buildDerivationPath(components: DerivationPathComponents): string;
+/**
+ * Validate seed phrase (BIP39)
+ *
+ * @param seedPhrase - Seed phrase to validate
+ * @returns True if valid BIP39 phrase
+ */
+export declare function validateSeedPhrase(seedPhrase: string): boolean;
+/**
+ * Generate seed from seed phrase
+ *
+ * @param seedPhrase - BIP39 seed phrase
+ * @param passphrase - Optional passphrase (default empty)
+ * @returns Seed bytes
+ */
+export declare function generateSeedFromMnemonic(seedPhrase: string, passphrase?: string): Buffer;
+/**
+ * Generate mnemonic from entropy
+ *
+ * @param strength - Entropy strength in bits (128, 160, 192, 224, 256)
+ * @param rng - Optional RNG function
+ * @returns BIP39 mnemonic phrase
+ */
+export declare function generateMnemonic(strength?: number, rng?: (size: number) => Buffer): string;
+/**
+ * Derive Ethereum-compatible key
+ *
+ * @param seed - Seed bytes
+ * @param derivationPath - Derivation path (default: "m/44'/60'/0'/0/0")
+ * @returns Derived key with ETH address
+ */
+export declare function deriveEthKey(seed: Buffer, derivationPath?: string): DerivedKey;
+/**
+ * Derive Polkadot-compatible key
+ *
+ * Uses SR25519 for key derivation and SS58 for address encoding.
+ *
+ * @param seed - Seed bytes
+ * @param derivationPath - Derivation path (default: "//hard//stash")
+ * @returns Derived key with Polkadot address
+ */
+export declare function derivePolkadotKey(seed: Buffer, derivationPath?: string): DerivedKey;
+/**
+ * Derive Solana-compatible key
+ *
+ * @param seed - Seed bytes
+ * @param derivationPath - Derivation path (default: "m/44'/501'/0'/0'/0'")
+ * @returns Derived key with Solana address
+ */
+export declare function deriveSolanaKey(seed: Buffer, derivationPath?: string): DerivedKey;
+/**
+ * Get default derivation path for chain
+ *
+ * @param chain - Blockchain type
+ * @returns Default derivation path
+ */
+export declare function getDefaultDerivationPath(chain: string): string;
+/**
+ * Derive wallet key based on creation method
+ *
+ * @param method - Wallet creation method
+ * @param seedPhrase - Seed phrase (for 'seed' and 'mnemonic' methods)
+ * @param privateKey - Private key (for 'private-key' method)
+ * @param derivationPath - Custom derivation path
+ * @param chain - Blockchain type
+ * @returns Derived key information
+ */
+export declare function deriveWalletKey(method: WalletCreationMethod, seedPhrase?: string, privateKey?: string, derivationPath?: string, chain?: string): DerivedKey;
+//# sourceMappingURL=key-derivation.d.ts.map