agentvault 1.0.0

package/dist/cli/commands/wallet-multi-send.js

@@ -0,0 +1,195 @@
+/**
+ * Wallet Multi-Send Command
+ *
+ * CLI command to send transactions across multiple chains in parallel.
+ * Part of Phase 5C: Cross-Chain Actions.
+ */
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { listAgentWallets, getWallet } from '../../src/wallet/wallet-manager.js';
+import { createChainDispatcher } from '../../src/wallet/chain-dispatcher.js';
+import { createCrossChainAggregator } from '../../src/wallet/cross-chain-aggregator.js';
+/**
+ * Handle multi-send command
+ */
+export async function handleMultiSend(agentId) {
+    console.log(chalk.bold('\n💸 Multi-Chain Send\n'));
+    console.log(chalk.yellow('[Experimental] This feature is under active development and may change.\n'));
+    const walletIds = listAgentWallets(agentId);
+    if (walletIds.length === 0) {
+        console.log(chalk.yellow('No wallets found for this agent'));
+        return;
+    }
+    const wallets = [];
+    for (const walletId of walletIds) {
+        try {
+            const wallet = getWallet(agentId, walletId);
+            if (wallet) {
+                wallets.push(wallet);
+            }
+        }
+        catch (_error) {
+            console.log(chalk.yellow(`Failed to load wallet ${walletId}`));
+        }
+    }
+    if (wallets.length === 0) {
+        console.log(chalk.yellow('No wallets could be loaded'));
+        return;
+    }
+    console.log(chalk.cyan(`Found ${wallets.length} wallet(s)\n`));
+    for (const wallet of wallets) {
+        console.log(chalk.dim(`[${wallet.id} - ${wallet.chain.toUpperCase()}]`));
+    }
+    console.log();
+    const { actionType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'actionType',
+            message: 'What would you like to do?',
+            default: 'send-all',
+            choices: [
+                { name: 'send-all', value: 'send-all' },
+                { name: 'send-specific', value: 'send-specific' },
+                { name: 'balance-check', value: 'balance-check' },
+                { name: 'batch-send', value: 'batch-send' },
+            ],
+        },
+    ]);
+    if (actionType === 'balance-check') {
+        await checkBalances(wallets);
+        return;
+    }
+    let selectedWallets;
+    if (actionType === 'send-specific' || actionType === 'batch-send') {
+        const { selectedIds } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedIds',
+                message: 'Select wallets to include:',
+                choices: wallets.map((w) => ({ name: w.id, value: w.id, checked: false })),
+            },
+        ]);
+        selectedWallets = wallets.filter((w) => selectedIds.includes(w.id));
+        if (selectedWallets.length === 0) {
+            console.log(chalk.yellow('No wallets selected'));
+            return;
+        }
+    }
+    else {
+        selectedWallets = wallets;
+    }
+    const { amount } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'amount',
+            message: 'Amount to send to each wallet:',
+            default: '0.01',
+        },
+    ]);
+    const { memo } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'memo',
+            message: 'Memo (optional):',
+            default: '',
+        },
+    ]);
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Send ${selectedWallets.length} transactions (${amount}${memo ? ' + memo' : ''})?`,
+            default: false,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.yellow('\nMulti-chain send cancelled'));
+        return;
+    }
+    const spinner = ora('Preparing transactions...').start();
+    try {
+        const actions = [];
+        for (const wallet of selectedWallets) {
+            const action = {
+                walletId: wallet.id,
+                chain: wallet.chain,
+                request: {
+                    to: '',
+                    amount,
+                    chain: wallet.chain,
+                },
+            };
+            actions.push(action);
+        }
+        const aggregator = createCrossChainAggregator({
+            maxConcurrency: 5,
+            continueOnError: false,
+        });
+        const results = await aggregator.execute(actions);
+        spinner.succeed(`Executed ${results.total} actions (${results.succeeded} succeeded, ${results.failed} failed)`);
+        console.log();
+        console.log(chalk.cyan('Execution Summary:'));
+        console.table(results.results.map((r) => ({
+            Chain: r.action.chain,
+            Wallet: r.action.walletId,
+            Success: r.success,
+            TxHash: r.txHash || 'N/A',
+            Error: r.error || 'N/A',
+        })));
+        console.log();
+        console.log(chalk.green('✓ Multi-chain send complete'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Execution failed: ${message}`);
+    }
+}
+/**
+ * Check balances across multiple wallets
+ */
+async function checkBalances(wallets) {
+    console.log(chalk.bold('\n📊 Balance Check\n'));
+    const spinner = ora('Checking balances...').start();
+    try {
+        const dispatcher = createChainDispatcher();
+        const balances = [];
+        for (const wallet of wallets) {
+            try {
+                const balance = await dispatcher.getBalance(wallet);
+                balances.push({
+                    wallet,
+                    balance: `${balance.amount} ${balance.denomination}`,
+                    error: undefined,
+                });
+            }
+            catch (_error) {
+                balances.push({
+                    wallet,
+                    balance: '0',
+                    error: _error instanceof Error ? _error.message : 'Unknown error',
+                });
+            }
+        }
+        spinner.succeed('Balance check complete');
+        console.log();
+        console.log(chalk.cyan('Balance Summary:'));
+        console.table(balances.map((b) => ({
+            Chain: b.wallet.chain,
+            Address: b.wallet.address,
+            Balance: b.balance,
+            Error: b.error || 'N/A',
+        })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Balance check failed: ${message}`);
+    }
+}
+/**
+ * Export handler for use by wallet.ts
+ */
+export async function handleMultiSendWithArgs(args) {
+    await handleMultiSend(args.agentId);
+}
+//# sourceMappingURL=wallet-multi-send.js.map

package/dist/cli/commands/wallet-process-queue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Wallet Process Queue Command (Phase 5B/5D)
+ *
+ * CLI command to process pending transactions from canister queue.
+ * Part of Phase 5B: Agent-Initiated Transactions.
+ * Phase 5D: VetKeys threshold signing support.
+ */
+/**
+ * Handle process-queue command
+ */
+export declare function handleProcessQueue(agentId: string, canisterId: string): Promise<void>;
+/**
+ * Export handler for use by wallet.ts
+ */
+export declare function handleProcessQueueWithArgs(args: {
+    agentId: string;
+    canisterId: string;
+}): Promise<void>;
+//# sourceMappingURL=wallet-process-queue.d.ts.map

package/dist/cli/commands/wallet-process-queue.js

@@ -0,0 +1,209 @@
+/**
+ * Wallet Process Queue Command (Phase 5B/5D)
+ *
+ * CLI command to process pending transactions from canister queue.
+ * Part of Phase 5B: Agent-Initiated Transactions.
+ * Phase 5D: VetKeys threshold signing support.
+ */
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { CkEthProvider, PolkadotProvider, SolanaProvider } from '../../src/wallet/index.js';
+/**
+ * Handle process-queue command
+ */
+export async function handleProcessQueue(agentId, canisterId) {
+    console.log(chalk.bold('\n🔄 Process Transaction Queue\n'));
+    console.log(chalk.yellow('[Experimental] This feature is under active development and may change.\n'));
+    const { createActor, createAnonymousAgent } = await import('../../src/canister/actor.js');
+    const spinner = ora('Connecting to canister...').start();
+    try {
+        const agent = createAnonymousAgent();
+        const actor = createActor(canisterId, agent);
+        spinner.succeed('Connected to canister');
+        const stats = await actor.getTransactionQueueStats();
+        if (stats.total === 0) {
+            console.log(chalk.yellow('No transactions in queue'));
+            return;
+        }
+        console.log();
+        console.log(chalk.cyan('Queue Statistics:'));
+        console.log(`  Total:     ${stats.total}`);
+        console.log(`  Pending:   ${stats.pending}`);
+        console.log(`  Queued:    ${stats.queued}`);
+        console.log(`  Signed:     ${stats.signed}`);
+        console.log(`  Completed:  ${stats.completed}`);
+        console.log(`  Failed:     ${stats.failed}`);
+        console.log();
+        const pending = await actor.getPendingTransactions();
+        if (pending.length === 0) {
+            console.log(chalk.yellow('No pending transactions to process'));
+            return;
+        }
+        console.log(chalk.cyan(`Found ${pending.length} pending transaction(s)\n`));
+        const { processAll } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'processAll',
+                message: `Process all ${pending.length} pending transactions?`,
+                default: false,
+            },
+        ]);
+        if (!processAll) {
+            console.log(chalk.yellow('\nProcessing cancelled'));
+            return;
+        }
+        spinner.start('Processing transactions...');
+        let processed = 0;
+        let succeeded = 0;
+        let failed = 0;
+        for (const tx of pending) {
+            const result = await processTransaction(tx, agentId, actor);
+            processed++;
+            if (result.success) {
+                succeeded++;
+                spinner.text = `Processed ${processed}/${pending.length} transactions...`;
+            }
+            else {
+                failed++;
+                spinner.warn(`Transaction ${tx.id} failed: ${result.error}`);
+            }
+        }
+        spinner.succeed(`Processed ${processed} transactions (${succeeded} succeeded, ${failed} failed)`);
+        console.log();
+        console.log(chalk.green('✓ Queue processing complete'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Processing failed: ${message}`);
+    }
+}
+/**
+ * Process a single transaction with VetKeys threshold signing
+ */
+async function processTransaction(tx, agentId, actor) {
+    try {
+        const { getWallet } = await import('../../src/wallet/wallet-manager.js');
+        const wallet = getWallet(agentId, tx.action.walletId);
+        if (!wallet) {
+            await actor.markTransactionFailed(tx.id, 'Wallet not found');
+            return { success: false, error: 'Wallet not found' };
+        }
+        const action = mapActionToRequest(tx.action);
+        // Phase 5D: VetKeys threshold signing for transactions with threshold > 1
+        const threshold = tx.action.threshold ? Number(tx.action.threshold) : 1;
+        if (threshold > 1) {
+            console.log(chalk.yellow(`Transaction ${tx.id} requires threshold signatures (${threshold} of ${tx.action.threshold ? Number(tx.action.threshold) : 3})...`));
+            const { createVetKeysAdapter } = await import('../../src/wallet/vetkeys-adapter.js');
+            const vetKeys = createVetKeysAdapter({
+                threshold: threshold,
+                totalParties: 3,
+                encryptionAlgorithm: 'aes-256-gcm',
+            });
+            const thresholdResult = await vetKeys.initiateThresholdSignature(tx.id, wallet, action);
+            if (!thresholdResult.success) {
+                await actor.markTransactionFailed(tx.id, thresholdResult.error);
+                return {
+                    success: false,
+                    error: thresholdResult.error,
+                };
+            }
+            await actor.markTransactionSigned(tx.id, thresholdResult.signature || '');
+            console.log(chalk.green(`✓ Threshold signature completed for ${tx.id}`));
+            return {
+                success: true,
+                txHash: 'threshold-signed',
+            };
+        }
+        else {
+            // Normal signing (threshold = 1)
+            const signed = await signTransaction(wallet, action);
+            if (!signed) {
+                await actor.markTransactionFailed(tx.id, 'Signing failed');
+                return { success: false, error: 'Signing failed' };
+            }
+            await actor.markTransactionSigned(tx.id, signed.signature || '');
+            const provider = createProvider(wallet.chain);
+            const txResult = await provider.sendTransaction(wallet.address, action);
+            await actor.markTransactionCompleted(tx.id, txResult.hash);
+            return {
+                success: true,
+                txHash: txResult.hash,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        await actor.markTransactionFailed(tx.id, message);
+        return {
+            success: false,
+            error: message,
+        };
+    }
+}
+/**
+ * Map canister action to transaction request
+ */
+function mapActionToRequest(action) {
+    const params = new Map(action.parameters);
+    return {
+        to: params.get('to') || '',
+        amount: params.get('amount') || '0',
+        chain: (params.get('chain') || 'cketh'),
+        memo: params.get('memo'),
+        gasPrice: params.get('gasPrice'),
+        gasLimit: params.get('gasLimit'),
+    };
+}
+/**
+ * Sign transaction with wallet
+ */
+async function signTransaction(wallet, action) {
+    try {
+        const provider = createProvider(wallet.chain);
+        const signed = await provider.signTransaction({
+            to: action.to,
+            amount: action.amount,
+            chain: action.chain,
+        }, wallet.privateKey);
+        return signed;
+    }
+    catch (error) {
+        console.error('Failed to sign transaction:', error);
+        return null;
+    }
+}
+/**
+ * Create blockchain provider
+ */
+function createProvider(chain) {
+    switch (chain) {
+        case 'cketh':
+            return new CkEthProvider({
+                chain: 'cketh',
+                rpcUrl: '',
+                isTestnet: false,
+            });
+        case 'polkadot':
+            return new PolkadotProvider({
+                chain: 'polkadot',
+                rpcUrl: '',
+                isTestnet: false,
+            });
+        case 'solana':
+            return new SolanaProvider({
+                chain: 'solana',
+                rpcUrl: '',
+                isTestnet: false,
+            });
+        default:
+            throw new Error(`Unsupported chain: ${chain}`);
+    }
+}
+/**
+ * Export handler for use by wallet.ts
+ */
+export async function handleProcessQueueWithArgs(args) {
+    await handleProcessQueue(args.agentId, args.canisterId);
+}
+//# sourceMappingURL=wallet-process-queue.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Wallet Sign Command
+ *
+ * Sign transactions with wallet's private key.
+ */
+/**
+ * Handle wallet sign command
+ */
+export declare function handleSign(agentId: string, options?: {
+    output?: string;
+    json?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=wallet-sign.d.ts.map

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

@@ -0,0 +1,207 @@
+/**
+ * Wallet Sign Command
+ *
+ * Sign transactions with wallet's private key.
+ */
+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';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Format address for display
+ */
+function formatAddress(address, length = 10) {
+    if (address.length <= length * 2)
+        return address;
+    return `${address.slice(0, length)}...${address.slice(-length)}`;
+}
+/**
+ * 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 signed transaction
+ */
+function displaySignedTransaction(signedTx, chain) {
+    console.log();
+    console.log(chalk.cyan('Signed Transaction:'));
+    console.log(`  Chain:       ${chain.toUpperCase()}`);
+    console.log(`  Hash:        ${signedTx.txHash}`);
+    console.log(`  Signature:   ${signedTx.signature || 'Included in tx'}`);
+    console.log(`  Recipient:   ${formatAddress(signedTx.request.to)}`);
+    console.log(`  Amount:      ${signedTx.request.amount}`);
+}
+/**
+ * Save signed transaction to file
+ */
+function saveSignedTransaction(signedTx, agentId, chain) {
+    const outputDir = path.join(process.cwd(), '.soulrecall', 'signed-txs');
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const timestamp = Date.now();
+    const filename = `signed-tx-${agentId}-${chain}-${timestamp}.json`;
+    const filepath = path.join(outputDir, filename);
+    const data = JSON.stringify(signedTx, null, 2);
+    fs.writeFileSync(filepath, data, 'utf-8');
+    return filepath;
+}
+/**
+ * Handle wallet sign command
+ */
+export async function handleSign(agentId, options = {}) {
+    console.log(chalk.bold('\n✍️  Sign Transaction\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 to sign with:',
+            choices: wallets,
+        },
+    ]);
+    const wallet = getWallet(agentId, walletId);
+    if (!wallet) {
+        console.log(chalk.red('Wallet not found'));
+        return;
+    }
+    const chain = wallet.chain;
+    const txDetails = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'to',
+            message: 'Recipient address:',
+            validate: (input) => input.length > 0,
+        },
+        {
+            type: 'input',
+            name: 'amount',
+            message: 'Amount to send:',
+            validate: (input) => parseFloat(input) > 0,
+        },
+    ]);
+    if (chain === 'cketh' || chain === 'polkadot') {
+        const gasDetails = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'gasPrice',
+                message: 'Gas price (optional, leave empty for auto):',
+                default: '',
+            },
+            {
+                type: 'input',
+                name: 'gasLimit',
+                message: 'Gas limit (optional, leave empty for auto):',
+                default: '',
+            },
+        ]);
+        if (gasDetails.gasPrice)
+            txDetails.gasPrice = gasDetails.gasPrice;
+        if (gasDetails.gasLimit)
+            txDetails.gasLimit = gasDetails.gasLimit;
+    }
+    else if (chain === 'solana') {
+        const { memo } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'memo',
+                message: 'Memo (optional):',
+                default: '',
+            },
+        ]);
+        if (memo)
+            txDetails.memo = memo;
+    }
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Sign transaction to send ${txDetails.amount} to ${formatAddress(txDetails.to)}?`,
+            default: false,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.yellow('\nTransaction signing cancelled'));
+        return;
+    }
+    const spinner = ora('Signing transaction...').start();
+    try {
+        const provider = createProvider(chain);
+        await provider.connect();
+        if (!wallet.privateKey) {
+            throw new Error('Wallet has no private key available for signing');
+        }
+        const txRequest = {
+            to: txDetails.to,
+            amount: txDetails.amount,
+            chain: chain,
+            ...(txDetails.gasPrice && { gasPrice: txDetails.gasPrice }),
+            ...(txDetails.gasLimit && { gasLimit: txDetails.gasLimit }),
+            ...(txDetails.memo && { memo: txDetails.memo }),
+        };
+        const signedTx = await provider.signTransaction(txRequest, wallet.privateKey);
+        spinner.succeed('Transaction signed');
+        if (options.json) {
+            console.log(JSON.stringify(signedTx, null, 2));
+        }
+        else {
+            displaySignedTransaction(signedTx, chain);
+        }
+        if (options.output || await shouldSaveFile()) {
+            const filepath = saveSignedTransaction(signedTx, agentId, chain);
+            console.log();
+            console.log(chalk.green('✓'), `Signed transaction saved to: ${filepath}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Failed to sign transaction: ${message}`);
+    }
+}
+/**
+ * Prompt user to save file
+ */
+async function shouldSaveFile() {
+    const { save } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'save',
+            message: 'Save signed transaction to file?',
+            default: true,
+        },
+    ]);
+    return save;
+}
+//# sourceMappingURL=wallet-sign.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * Wallet Command
+ *
+ * Main wallet management command for SoulRecall.
+ * Provides CLI interface for wallet operations.
+ */
+import { Command } from 'commander';
+/**
+ * Create wallet command
+ */
+export declare function walletCommand(): Command;
+//# sourceMappingURL=wallet.d.ts.map