agentvault 1.0.1 → 1.0.2

package/dist/src/wallet/wallet-manager.js

@@ -0,0 +1,451 @@
+/**
+ * Wallet Manager
+ *
+ * Main wallet management module.
+ * Handles wallet creation, storage, and retrieval with per-agent isolation.
+ * Phase 5A: Added canister sync functionality.
+ */
+import { randomBytes } from 'node:crypto';
+import { saveWallet, loadWallet, deleteWallet, listWallets, walletExists, } from './wallet-storage.js';
+import { deriveWalletKey, validateSeedPhrase, generateMnemonic, } from './key-derivation.js';
+// Phase 5A: Canister imports (lazy load)
+let _createActor = null;
+let _canisterInitialized = false;
+/**
+ * Lazy load canister actor
+ */
+async function loadCanister() {
+    if (_canisterInitialized)
+        return;
+    try {
+        const { createActor } = await import('../canister/actor.js');
+        _createActor = createActor;
+        _canisterInitialized = true;
+    }
+    catch (error) {
+        console.warn('Canister integration not available:', error);
+    }
+}
+/**
+ * Get or create canister actor
+ */
+async function getCanisterActor(canisterId) {
+    await loadCanister();
+    if (!_createActor) {
+        throw new Error('Canister actor not initialized');
+    }
+    const { createAnonymousAgent } = await import('../canister/actor.js');
+    const agent = createAnonymousAgent();
+    return _createActor(canisterId, agent);
+}
+/**
+ * In-memory wallet connections cache
+ */
+const walletConnections = new Map();
+/**
+ * Generate unique wallet ID
+ *
+ * @returns Unique wallet ID
+ */
+function generateWalletId() {
+    const bytes = randomBytes(16);
+    return `wallet-${bytes.toString('hex')}`;
+}
+/**
+ * Create a new wallet
+ *
+ * @param options - Wallet creation options
+ * @param storageOptions - Storage options
+ * @returns Created wallet data
+ */
+export function createWallet(options, storageOptions = {}) {
+    // Derive wallet key
+    const derivedKey = deriveWalletKey(options.method, options.seedPhrase, options.privateKey, options.derivationPath, options.chain);
+    // Create wallet data object
+    const walletData = {
+        id: options.walletId || generateWalletId(),
+        agentId: options.agentId,
+        chain: options.chain,
+        address: derivedKey.address,
+        privateKey: options.method === 'private-key' ? derivedKey.privateKey : undefined,
+        mnemonic: (options.method === 'seed' || options.method === 'mnemonic')
+            ? options.seedPhrase
+            : undefined,
+        seedDerivationPath: derivedKey.derivationPath,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        creationMethod: options.method,
+        chainMetadata: options.chainMetadata,
+    };
+    // Save wallet to storage
+    saveWallet(walletData, storageOptions);
+    return walletData;
+}
+/**
+ * Import wallet from private key
+ *
+ * @param agentId - Agent ID
+ * @param chain - Blockchain type
+ * @param privateKey - Private key (hex)
+ * @param storageOptions - Storage options
+ * @returns Imported wallet data
+ */
+export function importWalletFromPrivateKey(agentId, chain, privateKey, storageOptions = {}) {
+    return createWallet({
+        agentId,
+        chain: chain,
+        method: 'private-key',
+        privateKey,
+    }, storageOptions);
+}
+/**
+ * Import wallet from seed phrase
+ *
+ * @param agentId - Agent ID
+ * @param chain - Blockchain type
+ * @param seedPhrase - BIP39 seed phrase
+ * @param derivationPath - Optional custom derivation path
+ * @param storageOptions - Storage options
+ * @returns Imported wallet data
+ */
+export function importWalletFromSeed(agentId, chain, seedPhrase, derivationPath, storageOptions = {}) {
+    return createWallet({
+        agentId,
+        chain: chain,
+        method: 'seed',
+        seedPhrase,
+        derivationPath,
+    }, storageOptions);
+}
+/**
+ * Import wallet from mnemonic
+ *
+ * @param agentId - Agent ID
+ * @param chain - Blockchain type
+ * @param mnemonic - BIP39 mnemonic phrase
+ * @param derivationPath - Optional custom derivation path
+ * @param storageOptions - Storage options
+ * @returns Imported wallet data
+ */
+export function importWalletFromMnemonic(agentId, chain, mnemonic, derivationPath, storageOptions = {}) {
+    return createWallet({
+        agentId,
+        chain: chain,
+        method: 'mnemonic',
+        seedPhrase: mnemonic,
+        derivationPath,
+    }, storageOptions);
+}
+/**
+ * Generate new wallet
+ *
+ * @param agentId - Agent ID
+ * @param chain - Blockchain type
+ * @param storageOptions - Storage options
+ * @returns Generated wallet data
+ */
+export function generateWallet(agentId, chain, storageOptions = {}) {
+    const mnemonic = generateMnemonic(128);
+    return importWalletFromSeed(agentId, chain, mnemonic, undefined, storageOptions);
+}
+/**
+ * Get wallet by ID
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param storageOptions - Storage options
+ * @returns Wallet data or null if not found
+ */
+export function getWallet(agentId, walletId, storageOptions = {}) {
+    return loadWallet(agentId, walletId, storageOptions);
+}
+/**
+ * List all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param storageOptions - Storage options
+ * @returns Array of wallet IDs
+ */
+export function listAgentWallets(agentId, storageOptions = {}) {
+    return listWallets(agentId, storageOptions);
+}
+/**
+ * Check if wallet exists
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param storageOptions - Storage options
+ * @returns True if wallet exists
+ */
+export function hasWallet(agentId, walletId, storageOptions = {}) {
+    return walletExists(agentId, walletId, storageOptions);
+}
+/**
+ * Remove wallet
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param storageOptions - Storage options
+ */
+export function removeWallet(agentId, walletId, storageOptions = {}) {
+    deleteWallet(agentId, walletId, storageOptions);
+    // Remove from connections cache
+    walletConnections.delete(`${agentId}:${walletId}`);
+}
+/**
+ * Clear all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param storageOptions - Storage options
+ */
+export function clearAgentWallets(agentId, storageOptions = {}) {
+    const walletIds = listWallets(agentId, storageOptions);
+    for (const walletId of walletIds) {
+        deleteWallet(agentId, walletId, storageOptions);
+        walletConnections.delete(`${agentId}:${walletId}`);
+    }
+}
+/**
+ * Cache wallet connection
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param provider - Provider instance
+ */
+export function cacheWalletConnection(agentId, walletId, provider) {
+    walletConnections.set(`${agentId}:${walletId}`, provider);
+}
+/**
+ * Get cached wallet connection
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @returns Cached provider or undefined
+ */
+export function getCachedConnection(agentId, walletId) {
+    return walletConnections.get(`${agentId}:${walletId}`);
+}
+/**
+ * Clear wallet connection cache
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ */
+export function clearCachedConnection(agentId, walletId) {
+    walletConnections.delete(`${agentId}:${walletId}`);
+}
+/**
+ * Validate seed phrase
+ *
+ * @param seedPhrase - Seed phrase to validate
+ * @returns True if valid
+ */
+export function validateSeedPhraseWrapper(seedPhrase) {
+    return validateSeedPhrase(seedPhrase);
+}
+// ==================== Phase 5A: Canister Sync Functions ====================
+/**
+ * Sync wallet to canister (register wallet metadata)
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param canisterId - Canister ID to sync to
+ * @returns Sync result
+ */
+export async function syncWalletToCanister(agentId, walletId, canisterId) {
+    try {
+        await loadCanister();
+        if (!_createActor) {
+            return { success: false, error: 'Canister not available' };
+        }
+        const wallet = getWallet(agentId, walletId);
+        if (!wallet) {
+            return { success: false, error: 'Wallet not found' };
+        }
+        const actor = await getCanisterActor(canisterId);
+        const result = await actor.registerWallet({
+            id: walletId,
+            agentId,
+            chain: wallet.chain,
+            address: wallet.address,
+            registeredAt: BigInt(wallet.createdAt),
+            status: { active: null },
+        });
+        if ('ok' in result) {
+            return {
+                success: true,
+                registeredAt: wallet.createdAt,
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: result.err,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Sync all wallets for an agent to canister
+ *
+ * @param agentId - Agent ID
+ * @param canisterId - Canister ID to sync to
+ * @returns Sync results
+ */
+export async function syncAgentWallets(agentId, canisterId) {
+    const walletIds = listAgentWallets(agentId);
+    const synced = [];
+    const failed = [];
+    for (const walletId of walletIds) {
+        const result = await syncWalletToCanister(agentId, walletId, canisterId);
+        if (result.success) {
+            synced.push(walletId);
+        }
+        else {
+            failed.push({
+                walletId,
+                error: result.error || 'Unknown error',
+            });
+        }
+    }
+    return { synced, failed };
+}
+/**
+ * Get wallet sync status
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param canisterId - Canister ID
+ * @returns Wallet sync status
+ */
+export async function getWalletSyncStatus(agentId, walletId, canisterId) {
+    try {
+        await loadCanister();
+        const localExists = hasWallet(agentId, walletId);
+        let inCanister = false;
+        let canisterStatus;
+        if (_createActor) {
+            const actor = await getCanisterActor(canisterId);
+            const result = await actor.getWallet(walletId);
+            if (result && result.length > 0) {
+                inCanister = true;
+                canisterStatus = result[0];
+            }
+        }
+        const wallet = localExists ? getWallet(agentId, walletId) : null;
+        const synced = inCanister && localExists && wallet && canisterStatus;
+        return {
+            walletId,
+            inCanister,
+            canisterStatus,
+            localExists,
+            synced,
+        };
+    }
+    catch (_error) {
+        return {
+            walletId,
+            inCanister: false,
+            localExists: hasWallet(agentId, walletId),
+            synced: false,
+        };
+    }
+}
+/**
+ * List wallets from canister
+ *
+ * @param agentId - Agent ID
+ * @param canisterId - Canister ID
+ * @returns Array of canister wallet info
+ */
+export async function listCanisterWallets(agentId, canisterId) {
+    try {
+        await loadCanister();
+        if (!_createActor) {
+            return [];
+        }
+        const actor = await getCanisterActor(canisterId);
+        return await actor.listWallets(agentId);
+    }
+    catch (error) {
+        console.error('Failed to list canister wallets:', error);
+        return [];
+    }
+}
+/**
+ * Deregister wallet from canister
+ *
+ * @param walletId - Wallet ID
+ * @param canisterId - Canister ID
+ * @returns Deregistration result
+ */
+export async function deregisterWalletFromCanister(walletId, canisterId) {
+    try {
+        await loadCanister();
+        if (!_createActor) {
+            return { success: false, error: 'Canister not available' };
+        }
+        const actor = await getCanisterActor(canisterId);
+        const result = await actor.deregisterWallet(walletId);
+        if ('ok' in result) {
+            return { success: true };
+        }
+        else {
+            return {
+                success: false,
+                error: result.err,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Update wallet status in canister
+ *
+ * @param walletId - Wallet ID
+ * @param status - New status
+ * @param canisterId - Canister ID
+ * @returns Update result
+ */
+export async function updateCanisterWalletStatus(walletId, status, canisterId) {
+    try {
+        await loadCanister();
+        if (!_createActor) {
+            return { success: false, error: 'Canister not available' };
+        }
+        const actor = await getCanisterActor(canisterId);
+        const statusVariant = status === 'active'
+            ? { active: null }
+            : status === 'inactive'
+                ? { inactive: null }
+                : { revoked: null };
+        const result = await actor.updateWalletStatus(walletId, statusVariant);
+        if ('ok' in result) {
+            return { success: true };
+        }
+        else {
+            return {
+                success: false,
+                error: result.err,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=wallet-manager.js.map

package/dist/src/wallet/wallet-storage.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Wallet Storage Module
+ *
+ * Manages encrypted wallet persistence in ~/.agentvault/wallets/
+ * Provides per-agent wallet isolation and encryption.
+ */
+import type { WalletData, WalletStorageOptions } from './types.js';
+/**
+ * Get base directory for wallet storage
+ *
+ * @param options - Storage options
+ * @returns Wallet base directory
+ */
+export declare function getWalletBaseDir(options?: WalletStorageOptions): string;
+/**
+ * Get agent-specific wallet directory
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ * @returns Agent wallet directory
+ */
+export declare function getAgentWalletDir(agentId: string, options?: WalletStorageOptions): string;
+/**
+ * Get wallet file path
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns Wallet file path
+ */
+export declare function getWalletFilePath(agentId: string, walletId: string, options?: WalletStorageOptions): string;
+/**
+ * Ensure wallet directories exist
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ */
+export declare function ensureWalletDirectories(agentId: string, options?: WalletStorageOptions): void;
+/**
+ * Save wallet to encrypted storage
+ *
+ * @param wallet - Wallet data to save
+ * @param options - Storage options
+ */
+export declare function saveWallet(wallet: WalletData, options?: WalletStorageOptions): void;
+/**
+ * Load wallet from storage
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns Loaded wallet data or null if not found
+ */
+export declare function loadWallet(agentId: string, walletId: string, options?: WalletStorageOptions): WalletData | null;
+/**
+ * Delete wallet from storage
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ */
+export declare function deleteWallet(agentId: string, walletId: string, options?: WalletStorageOptions): void;
+/**
+ * List all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ * @returns Array of wallet IDs
+ */
+export declare function listWallets(agentId: string, options?: WalletStorageOptions): string[];
+/**
+ * List all agents with wallets
+ *
+ * @param options - Storage options
+ * @returns Array of agent IDs
+ */
+export declare function listAgents(options?: WalletStorageOptions): string[];
+/**
+ * Check if wallet exists
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns True if wallet exists
+ */
+export declare function walletExists(agentId: string, walletId: string, options?: WalletStorageOptions): boolean;
+/**
+ * Get wallet file stats
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns Wallet file stats or null if not found
+ */
+export declare function getWalletStats(agentId: string, walletId: string, options?: WalletStorageOptions): {
+    size: number;
+    modified: Date;
+    created: Date;
+} | null;
+/**
+ * Backup all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param backupPath - Path to save backup
+ * @param options - Storage options
+ */
+export declare function backupWallets(agentId: string, backupPath: string, options?: WalletStorageOptions): void;
+/**
+ * Restore wallets from backup
+ *
+ * @param agentId - Agent ID
+ * @param backupPath - Path to backup directory
+ * @param options - Storage options
+ */
+export declare function restoreWallets(agentId: string, backupPath: string, options?: WalletStorageOptions): void;
+/**
+ * Clear all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ */
+export declare function clearWallets(agentId: string, options?: WalletStorageOptions): void;
+/**
+ * Get total storage size for an agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ * @returns Total size in bytes
+ */
+export declare function getWalletStorageSize(agentId: string, options?: WalletStorageOptions): number;
+//# sourceMappingURL=wallet-storage.d.ts.map