agentvault 1.0.0

package/dist/cli/commands/wallet-export.js

@@ -0,0 +1,140 @@
+/**
+ * Wallet Export Command
+ *
+ * Export all wallets for an agent to a backup file.
+ */
+import { listAgentWallets, getWallet } from '../../src/wallet/index.js';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+/**
+ * Create backup directory
+ */
+function ensureBackupDir() {
+    const backupDir = path.join(process.cwd(), 'backups');
+    if (!fs.existsSync(backupDir)) {
+        fs.mkdirSync(backupDir, { recursive: true });
+    }
+    return backupDir;
+}
+/**
+ * Generate backup filename
+ */
+function generateBackupFilename(agentId, format) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const ext = format === 'encrypted' ? 'backup' : 'json';
+    return `soulrecall-backup-${agentId}-${timestamp}.${ext}`;
+}
+/**
+ * Display wallet summary
+ */
+function displayWalletSummary(wallets) {
+    console.log();
+    console.log(chalk.cyan('Wallets to export:'));
+    for (const wallet of wallets) {
+        console.log(`  - ${wallet.chain.toUpperCase()}: ${wallet.address}`);
+    }
+    console.log(`  Total: ${wallets.length} wallet(s)`);
+}
+/**
+ * Encrypt data with password
+ */
+function encryptData(data, password) {
+    const salt = crypto.randomBytes(16);
+    const iv = crypto.randomBytes(16);
+    const key = crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    let encrypted = cipher.update(data, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag();
+    const encryptedWithAuth = `${encrypted}.${authTag.toString('hex')}`;
+    return {
+        encrypted: encryptedWithAuth,
+        iv: iv.toString('hex'),
+        salt: salt.toString('hex'),
+    };
+}
+/**
+ * Handle wallet export command
+ */
+export async function handleExport(agentId, options = {}) {
+    console.log(chalk.bold('\n📦 Export Wallets\n'));
+    const walletIds = listAgentWallets(agentId);
+    if (walletIds.length === 0) {
+        console.log(chalk.yellow('No wallets found for this agent'));
+        return;
+    }
+    const wallets = walletIds.map(id => getWallet(agentId, id)).filter(Boolean);
+    displayWalletSummary(wallets);
+    const { format } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'format',
+            message: 'Select export format:',
+            choices: [
+                { name: 'JSON (plain text, easy to read)', value: 'json' },
+                { name: 'Encrypted (password-protected)', value: 'encrypted' },
+            ],
+            default: options.format || 'json',
+        },
+    ]);
+    const backupDir = ensureBackupDir();
+    const filename = options.output || generateBackupFilename(agentId, format);
+    const filepath = path.join(backupDir, filename);
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Export ${wallets.length} wallet(s) to ${filepath}?`,
+            default: true,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.yellow('\nExport cancelled'));
+        return;
+    }
+    const spinner = ora('Exporting wallets...').start();
+    try {
+        const backup = {
+            version: '1.0',
+            agentId,
+            exportedAt: Date.now(),
+            format,
+            wallets,
+        };
+        let data = JSON.stringify(backup, null, 2);
+        if (format === 'encrypted') {
+            const { password } = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'Enter encryption password:',
+                    validate: (input) => input.length >= 8,
+                },
+            ]);
+            const { encrypted, iv, salt } = encryptData(data, password);
+            backup.encrypted = true;
+            backup.iv = iv;
+            backup.salt = salt;
+            data = JSON.stringify(backup, null, 2);
+            data = JSON.stringify({ encrypted });
+        }
+        fs.writeFileSync(filepath, data, 'utf-8');
+        spinner.succeed('Wallets exported successfully');
+        console.log();
+        console.log(chalk.green('✓'), `Export saved to: ${filepath}`);
+        console.log(`  Size: ${(data.length / 1024).toFixed(2)} KB`);
+        if (format === 'json') {
+            console.log();
+            console.log(chalk.yellow('⚠'), 'This file contains private keys - keep it secure!');
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Failed to export wallets: ${message}`);
+    }
+}
+//# sourceMappingURL=wallet-export.js.map

package/dist/cli/commands/wallet-history.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wallet History Command
+ *
+ * Display transaction history for a wallet.
+ */
+/**
+ * Handle wallet history command
+ */
+export declare function handleHistory(agentId: string, json?: boolean): Promise<void>;
+//# sourceMappingURL=wallet-history.d.ts.map

package/dist/cli/commands/wallet-history.js

@@ -0,0 +1,127 @@
+/**
+ * Wallet History Command
+ *
+ * Display transaction history for a wallet.
+ */
+import { CkEthProvider } from '../../src/wallet/providers/cketh-provider.js';
+import { PolkadotProvider } from '../../src/wallet/providers/polkadot-provider.js';
+import { SolanaProvider } from '../../src/wallet/providers/solana-provider.js';
+import { getWallet, listAgentWallets } from '../../src/wallet/index.js';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+/**
+ * Format address for display
+ */
+function formatAddress(address, length = 8) {
+    if (address.length <= length * 2)
+        return address;
+    return `${address.slice(0, length)}...${address.slice(-length)}`;
+}
+/**
+ * Get status color
+ */
+function getStatusColor(status) {
+    switch (status) {
+        case 'confirmed':
+            return chalk.green(status);
+        case 'pending':
+            return chalk.yellow(status);
+        case 'failed':
+            return chalk.red(status);
+        default:
+            return chalk.white(status);
+    }
+}
+/**
+ * Create provider for chain
+ */
+function createProvider(chain) {
+    switch (chain) {
+        case 'cketh':
+            return new CkEthProvider({
+                chain: 'cketh',
+                rpcUrl: CkEthProvider.getDefaultRpcUrl(),
+                isTestnet: false,
+            });
+        case 'polkadot':
+            return new PolkadotProvider({
+                chain: 'polkadot',
+                rpcUrl: 'wss://rpc.polkadot.io',
+                isTestnet: false,
+            });
+        case 'solana':
+            return new SolanaProvider({
+                chain: 'solana',
+                rpcUrl: 'https://api.mainnet-beta.solana.com',
+                isTestnet: false,
+            });
+        default:
+            throw new Error(`Unsupported chain: ${chain}`);
+    }
+}
+/**
+ * Display transaction history
+ */
+function displayTransactions(transactions) {
+    if (transactions.length === 0) {
+        console.log(chalk.yellow('No transactions found'));
+        return;
+    }
+    console.log();
+    console.log(chalk.cyan(`Transaction History (${transactions.length} transactions):\n`));
+    const table = [];
+    for (const tx of transactions) {
+        table.push({
+            Hash: formatAddress(tx.hash),
+            From: formatAddress(tx.from),
+            To: formatAddress(tx.to),
+            Amount: `${tx.amount}`,
+            Status: getStatusColor(tx.status),
+            Fee: tx.fee || 'N/A',
+        });
+    }
+    console.table(table);
+}
+/**
+ * Handle wallet history command
+ */
+export async function handleHistory(agentId, json = false) {
+    console.log(chalk.bold('\n📜 Wallet History\n'));
+    const wallets = listAgentWallets(agentId);
+    if (wallets.length === 0) {
+        console.log(chalk.yellow('No wallets found for this agent'));
+        return;
+    }
+    const { walletId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'walletId',
+            message: 'Select wallet:',
+            choices: wallets,
+        },
+    ]);
+    const wallet = getWallet(agentId, walletId);
+    if (!wallet) {
+        console.log(chalk.red('Wallet not found'));
+        return;
+    }
+    const spinner = ora('Fetching transaction history...').start();
+    try {
+        const provider = createProvider(wallet.chain);
+        await provider.connect();
+        const transactions = await provider.getTransactionHistory(wallet.address);
+        spinner.succeed('Transaction history fetched');
+        if (json) {
+            console.log(JSON.stringify(transactions, null, 2));
+        }
+        else {
+            displayTransactions(transactions);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Failed to fetch history: ${message}`);
+    }
+}
+//# sourceMappingURL=wallet-history.js.map

package/dist/cli/commands/wallet-import.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wallet Import Command
+ *
+ * Import wallets from an exported backup file.
+ */
+/**
+ * Handle wallet import command
+ */
+export declare function handleImport(agentId: string, filePath: string): Promise<void>;
+//# sourceMappingURL=wallet-import.d.ts.map

package/dist/cli/commands/wallet-import.js

@@ -0,0 +1,209 @@
+/**
+ * Wallet Import Command
+ *
+ * Import wallets from an exported backup file.
+ */
+import { importWalletFromPrivateKey, importWalletFromSeed } from '../../src/wallet/index.js';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import * as crypto from 'node:crypto';
+/**
+ * Decrypt data with password
+ */
+function decryptData(encryptedData, password, ivHex, saltHex) {
+    const iv = Buffer.from(ivHex || '', 'hex');
+    const salt = Buffer.from(saltHex || '', 'hex');
+    const key = crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
+    const [encrypted, authTagHex] = encryptedData.split('.');
+    const authTag = Buffer.from(authTagHex || '', 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted || '', 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+/**
+ * Load backup file
+ */
+function loadBackupFile(filepath) {
+    if (!fs.existsSync(filepath)) {
+        throw new Error(`Backup file not found: ${filepath}`);
+    }
+    const data = fs.readFileSync(filepath, 'utf-8');
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        throw new Error('Invalid backup file format');
+    }
+}
+/**
+ * Decrypt backup if needed
+ */
+async function loadBackup(filepath) {
+    const loaded = loadBackupFile(filepath);
+    if (loaded.encrypted && loaded.iv && loaded.salt && loaded.encrypted) {
+        const encryptedData = loaded.encrypted;
+        const { password } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Enter decryption password:',
+            },
+        ]);
+        try {
+            const decrypted = decryptData(encryptedData, password, loaded.iv, loaded.salt);
+            return JSON.parse(decrypted);
+        }
+        catch {
+            throw new Error('Failed to decrypt backup - incorrect password or corrupted file');
+        }
+    }
+    return loaded;
+}
+/**
+ * Validate backup structure
+ */
+function validateBackup(backup) {
+    if (!backup.version || !backup.agentId || !backup.wallets || !Array.isArray(backup.wallets)) {
+        throw new Error('Invalid backup structure');
+    }
+    if (backup.wallets.length === 0) {
+        throw new Error('Backup contains no wallets');
+    }
+    for (const wallet of backup.wallets) {
+        if (!wallet.id || !wallet.chain || !wallet.address) {
+            throw new Error('Invalid wallet data in backup');
+        }
+    }
+}
+/**
+ * Display backup summary
+ */
+function displayBackupSummary(backup) {
+    console.log();
+    console.log(chalk.cyan('Backup Summary:'));
+    console.log(`  Version:    ${backup.version}`);
+    console.log(`  Agent ID:   ${backup.agentId}`);
+    console.log(`  Exported:   ${new Date(backup.exportedAt).toISOString()}`);
+    console.log(`  Format:     ${backup.format}`);
+    console.log(`  Wallets:    ${backup.wallets.length}`);
+    console.log();
+    console.log(chalk.cyan('Wallets:'));
+    for (const wallet of backup.wallets) {
+        console.log(`  - ${wallet.chain.toUpperCase()}: ${wallet.address}`);
+    }
+}
+/**
+ * Import wallet from backup
+ */
+async function importWallet(wallet, agentId, resolution) {
+    try {
+        if (wallet.privateKey) {
+            importWalletFromPrivateKey(agentId, wallet.chain, wallet.privateKey);
+        }
+        else if (wallet.mnemonic) {
+            importWalletFromSeed(agentId, wallet.chain, wallet.mnemonic, wallet.seedDerivationPath);
+        }
+        else {
+            console.log(chalk.yellow(`⚠ Skipping ${wallet.id}: No private key or mnemonic`));
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        if (error.message?.includes('already exists')) {
+            if (resolution === 'skip') {
+                console.log(chalk.yellow(`⊘ Skipping ${wallet.id}: Already exists`));
+            }
+            else if (resolution === 'overwrite') {
+                console.log(chalk.yellow(`⚠ Overwriting ${wallet.id}`));
+            }
+        }
+        else {
+            console.log(chalk.red(`✗ Failed to import ${wallet.id}: ${error.message}`));
+        }
+        return false;
+    }
+}
+/**
+ * Handle wallet import command
+ */
+export async function handleImport(agentId, filePath) {
+    console.log(chalk.bold('\n📥 Import Wallets\n'));
+    if (!filePath) {
+        const { path: inputPath } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Path to backup file:',
+                validate: (input) => input.length > 0,
+            },
+        ]);
+        filePath = inputPath;
+    }
+    const spinner = ora('Loading backup file...').start();
+    try {
+        const backup = await loadBackup(filePath);
+        validateBackup(backup);
+        spinner.succeed('Backup loaded');
+        displayBackupSummary(backup);
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Import ${backup.wallets.length} wallet(s) to agent ${agentId}?`,
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk.yellow('\nImport cancelled'));
+            return;
+        }
+        const { resolution } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'resolution',
+                message: 'How to handle existing wallets?',
+                choices: [
+                    { name: 'Skip existing wallets', value: 'skip' },
+                    { name: 'Overwrite existing wallets', value: 'overwrite' },
+                    { name: 'Rename with suffix', value: 'rename' },
+                ],
+                default: 'skip',
+            },
+        ]);
+        console.log();
+        console.log(chalk.cyan('Importing wallets...'));
+        let successCount = 0;
+        const skipCount = 0;
+        let failCount = 0;
+        for (const wallet of backup.wallets) {
+            const result = await importWallet(wallet, agentId, resolution);
+            if (result) {
+                successCount++;
+                console.log(chalk.green(`✓ Imported: ${wallet.id} (${wallet.chain})`));
+            }
+            else {
+                failCount++;
+            }
+        }
+        console.log();
+        console.log(chalk.cyan('Import Summary:'));
+        console.log(`  ✓ Successful: ${successCount}`);
+        console.log(`  ⊘ Skipped:    ${skipCount}`);
+        console.log(`  ✗ Failed:     ${failCount}`);
+        if (successCount > 0) {
+            console.log();
+            console.log(chalk.green('✓'), 'Wallets imported successfully');
+            console.log(chalk.yellow('⚠'), 'Keep your backup file secure until you verify all wallets work correctly');
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Failed to import wallets: ${message}`);
+    }
+}
+//# sourceMappingURL=wallet-import.js.map

package/dist/cli/commands/wallet-multi-send.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Wallet Multi-Send Command
+ *
+ * CLI command to send transactions across multiple chains in parallel.
+ * Part of Phase 5C: Cross-Chain Actions.
+ */
+/**
+ * Handle multi-send command
+ */
+export declare function handleMultiSend(agentId: string): Promise<void>;
+/**
+ * Export handler for use by wallet.ts
+ */
+export declare function handleMultiSendWithArgs(args: {
+    agentId: string;
+}): Promise<void>;
+//# sourceMappingURL=wallet-multi-send.d.ts.map