agentvault 1.0.0 → 1.0.2

package/macos-wallet-app/AgentVaultWallet/ViewModels/CreateWalletViewModel.swift

@@ -0,0 +1,137 @@
+import SwiftUI
+
+/// Manages the multi-step wallet creation flow
+@MainActor
+final class CreateWalletViewModel: ObservableObject {
+
+    enum Step: Int, CaseIterable {
+        case selectChain = 0
+        case generating = 1
+        case showMnemonic = 2
+        case confirmMnemonic = 3
+        case nameWallet = 4
+        case complete = 5
+
+        var title: String {
+            switch self {
+            case .selectChain: return "Select Network"
+            case .generating: return "Generating Wallet"
+            case .showMnemonic: return "Recovery Phrase"
+            case .confirmMnemonic: return "Confirm Backup"
+            case .nameWallet: return "Name Your Wallet"
+            case .complete: return "Wallet Created"
+            }
+        }
+    }
+
+    @Published var currentStep: Step = .selectChain
+    @Published var selectedChain: Chain = .ethereum
+    @Published var walletName: String = ""
+    @Published var mnemonic: String = ""
+    @Published var mnemonicWords: [String] = []
+    @Published var confirmationInput: String = ""
+    @Published var confirmWordIndices: [Int] = []  // Which words to verify
+    @Published var createdWallet: Wallet?
+    @Published var isProcessing: Bool = false
+    @Published var errorMessage: String?
+
+    /// Words the user needs to confirm (randomly selected from the mnemonic)
+    var wordsToConfirm: [(index: Int, word: String)] {
+        confirmWordIndices.compactMap { idx in
+            guard idx < mnemonicWords.count else { return nil }
+            return (index: idx, word: mnemonicWords[idx])
+        }
+    }
+
+    /// Whether the user can proceed from the current step
+    var canProceed: Bool {
+        switch currentStep {
+        case .selectChain: return true
+        case .generating: return false
+        case .showMnemonic: return true
+        case .confirmMnemonic: return isConfirmationValid
+        case .nameWallet: return !walletName.trimmingCharacters(in: .whitespaces).isEmpty
+        case .complete: return true
+        }
+    }
+
+    /// Validate mnemonic confirmation
+    var isConfirmationValid: Bool {
+        let inputWords = confirmationInput
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+            .components(separatedBy: .whitespaces)
+            .filter { !$0.isEmpty }
+
+        guard inputWords.count == confirmWordIndices.count else { return false }
+
+        for (i, idx) in confirmWordIndices.enumerated() {
+            guard i < inputWords.count, idx < mnemonicWords.count else { return false }
+            if inputWords[i] != mnemonicWords[idx].lowercased() { return false }
+        }
+        return true
+    }
+
+    func goToNext() {
+        guard let nextStep = Step(rawValue: currentStep.rawValue + 1) else { return }
+        withAnimation(.easeInOut(duration: 0.3)) {
+            currentStep = nextStep
+        }
+    }
+
+    func goBack() {
+        guard let prevStep = Step(rawValue: currentStep.rawValue - 1) else { return }
+        withAnimation(.easeInOut(duration: 0.3)) {
+            currentStep = prevStep
+        }
+    }
+
+    /// Generate a new wallet using the CLI bridge
+    func generateWallet(store: WalletStore) async {
+        isProcessing = true
+        errorMessage = nil
+        currentStep = .generating
+
+        do {
+            let name = walletName.isEmpty ? "\(selectedChain.displayName) Wallet" : walletName
+            let result = try await store.createWallet(chain: selectedChain, name: name)
+
+            createdWallet = result.wallet
+            if let m = result.mnemonic {
+                mnemonic = m
+                mnemonicWords = m.components(separatedBy: " ")
+                selectRandomConfirmationWords()
+            }
+
+            isProcessing = false
+            currentStep = .showMnemonic
+        } catch {
+            isProcessing = false
+            errorMessage = error.localizedDescription
+            currentStep = .selectChain
+        }
+    }
+
+    /// Select 3 random word indices for confirmation
+    private func selectRandomConfirmationWords() {
+        guard mnemonicWords.count >= 3 else { return }
+        var indices = Set<Int>()
+        while indices.count < 3 {
+            indices.insert(Int.random(in: 0..<mnemonicWords.count))
+        }
+        confirmWordIndices = indices.sorted()
+    }
+
+    func reset() {
+        currentStep = .selectChain
+        selectedChain = .ethereum
+        walletName = ""
+        mnemonic = ""
+        mnemonicWords = []
+        confirmationInput = ""
+        confirmWordIndices = []
+        createdWallet = nil
+        isProcessing = false
+        errorMessage = nil
+    }
+}

package/macos-wallet-app/AgentVaultWallet/ViewModels/ImportWalletViewModel.swift

@@ -0,0 +1,179 @@
+import SwiftUI
+import UniformTypeIdentifiers
+
+/// Manages the multi-step wallet import flow
+@MainActor
+final class ImportWalletViewModel: ObservableObject {
+
+    enum Step: Int, CaseIterable {
+        case selectChain = 0
+        case selectMethod = 1
+        case enterInput = 2
+        case nameWallet = 3
+        case importing = 4
+        case complete = 5
+
+        var title: String {
+            switch self {
+            case .selectChain: return "Select Network"
+            case .selectMethod: return "Import Method"
+            case .enterInput: return "Enter Details"
+            case .nameWallet: return "Name Your Wallet"
+            case .importing: return "Importing"
+            case .complete: return "Import Complete"
+            }
+        }
+    }
+
+    @Published var currentStep: Step = .selectChain
+    @Published var selectedChain: Chain = .ethereum
+    @Published var selectedMethod: ImportMethod = .mnemonic
+    @Published var walletName: String = ""
+    @Published var inputText: String = ""        // Mnemonic or private key
+    @Published var passwordInput: String = ""     // For keystore files
+    @Published var selectedFileURL: URL?          // For file-based imports
+    @Published var importedWallet: Wallet?
+    @Published var isProcessing: Bool = false
+    @Published var errorMessage: String?
+    @Published var showFileImporter: Bool = false
+
+    /// Available import methods for the selected chain
+    var availableMethods: [ImportMethod] {
+        selectedChain.supportedImportMethods
+    }
+
+    /// Whether the current input is valid enough to proceed
+    var isInputValid: Bool {
+        switch selectedMethod {
+        case .mnemonic:
+            return CryptoService.shared.isValidMnemonic(inputText)
+        case .privateKey:
+            let cleaned = inputText.trimmingCharacters(in: .whitespacesAndNewlines)
+            if selectedChain == .ethereum {
+                return CryptoService.shared.isValidEthPrivateKey(cleaned)
+            }
+            return cleaned.count >= 32
+        case .pemFile, .jwkFile, .keystoreJSON:
+            return selectedFileURL != nil
+        }
+    }
+
+    var canProceed: Bool {
+        switch currentStep {
+        case .selectChain: return true
+        case .selectMethod: return true
+        case .enterInput: return isInputValid
+        case .nameWallet: return !walletName.trimmingCharacters(in: .whitespaces).isEmpty
+        case .importing: return false
+        case .complete: return true
+        }
+    }
+
+    /// File types accepted for the current import method
+    var allowedFileTypes: [UTType] {
+        switch selectedMethod {
+        case .jwkFile: return [.json]
+        case .pemFile: return [UTType(filenameExtension: "pem") ?? .data]
+        case .keystoreJSON: return [.json]
+        default: return []
+        }
+    }
+
+    /// Placeholder text for the input field
+    var inputPlaceholder: String {
+        switch selectedMethod {
+        case .mnemonic: return "Enter your 12 or 24-word recovery phrase, separated by spaces..."
+        case .privateKey:
+            if selectedChain == .ethereum { return "Enter your hex-encoded private key (0x...)" }
+            return "Enter your private key..."
+        default: return ""
+        }
+    }
+
+    func goToNext() {
+        guard let nextStep = Step(rawValue: currentStep.rawValue + 1) else { return }
+        withAnimation(.easeInOut(duration: 0.3)) {
+            currentStep = nextStep
+        }
+    }
+
+    func goBack() {
+        guard let prevStep = Step(rawValue: currentStep.rawValue - 1) else { return }
+        withAnimation(.easeInOut(duration: 0.3)) {
+            currentStep = prevStep
+        }
+    }
+
+    /// Execute the import
+    func importWallet(store: WalletStore) async {
+        isProcessing = true
+        errorMessage = nil
+        currentStep = .importing
+
+        do {
+            let name = walletName.isEmpty ? "\(selectedChain.displayName) Import" : walletName
+
+            switch selectedMethod {
+            case .mnemonic:
+                importedWallet = try await store.importFromMnemonic(
+                    chain: selectedChain,
+                    mnemonic: inputText.trimmingCharacters(in: .whitespacesAndNewlines),
+                    name: name
+                )
+
+            case .privateKey:
+                importedWallet = try await store.importFromPrivateKey(
+                    chain: selectedChain,
+                    privateKey: inputText.trimmingCharacters(in: .whitespacesAndNewlines),
+                    name: name
+                )
+
+            case .jwkFile:
+                guard let url = selectedFileURL else { throw ImportError.noFileSelected }
+                importedWallet = try await store.importFromJWK(fileURL: url, name: name)
+
+            case .pemFile:
+                guard let url = selectedFileURL else { throw ImportError.noFileSelected }
+                importedWallet = try await store.importFromPEM(fileURL: url, name: name)
+
+            case .keystoreJSON:
+                guard let url = selectedFileURL else { throw ImportError.noFileSelected }
+                importedWallet = try await store.importFromKeystore(
+                    fileURL: url,
+                    password: passwordInput,
+                    name: name
+                )
+            }
+
+            isProcessing = false
+            currentStep = .complete
+        } catch {
+            isProcessing = false
+            errorMessage = error.localizedDescription
+            currentStep = .enterInput
+        }
+    }
+
+    func reset() {
+        currentStep = .selectChain
+        selectedChain = .ethereum
+        selectedMethod = .mnemonic
+        walletName = ""
+        inputText = ""
+        passwordInput = ""
+        selectedFileURL = nil
+        importedWallet = nil
+        isProcessing = false
+        errorMessage = nil
+    }
+
+    enum ImportError: LocalizedError {
+        case noFileSelected
+
+        var errorDescription: String? {
+            switch self {
+            case .noFileSelected: return "No file was selected for import"
+            }
+        }
+    }
+}

package/macos-wallet-app/AgentVaultWallet/ViewModels/WalletStore.swift

@@ -0,0 +1,286 @@
+import SwiftUI
+import Combine
+
+/// Central state manager for all wallet operations.
+/// Acts as the single source of truth for wallet data in the app.
+@MainActor
+final class WalletStore: ObservableObject {
+
+    @Published var wallets: [Wallet] = []
+    @Published var isLoading: Bool = false
+    @Published var errorMessage: String?
+    @Published var selectedWalletId: UUID?
+
+    private let fileService = FileService.shared
+    private let keychain = KeychainService.shared
+    private let cliBridge = CLIBridge()
+    private let backupService = BackupService.shared
+
+    // MARK: - Computed Properties
+
+    var selectedWallet: Wallet? {
+        guard let id = selectedWalletId else { return nil }
+        return wallets.first { $0.id == id }
+    }
+
+    var walletsByChain: [Chain: [Wallet]] {
+        Dictionary(grouping: wallets, by: \.chain)
+    }
+
+    var totalWalletCount: Int { wallets.count }
+
+    var icpWallets: [Wallet] { wallets.filter { $0.chain == .icp } }
+    var ethWallets: [Wallet] { wallets.filter { $0.chain == .ethereum } }
+    var arweaveWallets: [Wallet] { wallets.filter { $0.chain == .arweave } }
+
+    // MARK: - Persistence
+
+    func loadWallets() {
+        do {
+            wallets = try fileService.loadWallets()
+        } catch {
+            errorMessage = "Failed to load wallets: \(error.localizedDescription)"
+            wallets = []
+        }
+    }
+
+    func saveWallets() {
+        do {
+            try fileService.saveWallets(wallets)
+        } catch {
+            errorMessage = "Failed to save wallets: \(error.localizedDescription)"
+        }
+    }
+
+    // MARK: - Create Wallet
+
+    /// Create a new wallet via the CLI bridge
+    func createWallet(chain: Chain, name: String) async throws -> WalletCreationResult {
+        isLoading = true
+        defer { isLoading = false }
+
+        let result = try await cliBridge.generateWallet(chain: chain, name: name)
+
+        let walletId = UUID()
+        let wallet = Wallet(
+            id: walletId,
+            name: name,
+            chain: chain,
+            address: result.address,
+            isImported: false,
+            derivationPath: chain.derivationPath,
+            hasMnemonicBackup: result.mnemonic != nil
+        )
+
+        // Save secrets to Keychain
+        if let mnemonic = result.mnemonic {
+            try keychain.saveMnemonic(mnemonic, forWalletId: walletId)
+        }
+        if let privateKey = result.privateKey {
+            try keychain.savePrivateKey(privateKey, forWalletId: walletId)
+        }
+
+        // Add to wallet list and persist
+        wallets.append(wallet)
+        saveWallets()
+
+        return WalletCreationResult(
+            wallet: wallet,
+            mnemonic: result.mnemonic,
+            privateKeyHex: result.privateKey,
+            jwkData: nil
+        )
+    }
+
+    // MARK: - Import Wallet
+
+    /// Import a wallet from a mnemonic phrase
+    func importFromMnemonic(chain: Chain, mnemonic: String, name: String) async throws -> Wallet {
+        isLoading = true
+        defer { isLoading = false }
+
+        let result = try await cliBridge.importFromMnemonic(chain: chain, mnemonic: mnemonic, name: name)
+
+        let walletId = UUID()
+        let wallet = Wallet(
+            id: walletId,
+            name: name,
+            chain: chain,
+            address: result.address,
+            isImported: true,
+            derivationPath: chain.derivationPath,
+            hasMnemonicBackup: true
+        )
+
+        try keychain.saveMnemonic(mnemonic, forWalletId: walletId)
+        if let privateKey = result.privateKey {
+            try keychain.savePrivateKey(privateKey, forWalletId: walletId)
+        }
+
+        wallets.append(wallet)
+        saveWallets()
+        return wallet
+    }
+
+    /// Import a wallet from a private key
+    func importFromPrivateKey(chain: Chain, privateKey: String, name: String) async throws -> Wallet {
+        isLoading = true
+        defer { isLoading = false }
+
+        let result = try await cliBridge.importFromPrivateKey(chain: chain, privateKey: privateKey, name: name)
+
+        let walletId = UUID()
+        let wallet = Wallet(
+            id: walletId,
+            name: name,
+            chain: chain,
+            address: result.address,
+            isImported: true,
+            derivationPath: chain.derivationPath,
+            hasMnemonicBackup: false
+        )
+
+        try keychain.savePrivateKey(privateKey, forWalletId: walletId)
+
+        wallets.append(wallet)
+        saveWallets()
+        return wallet
+    }
+
+    /// Import an Arweave wallet from a JWK file
+    func importFromJWK(fileURL: URL, name: String) async throws -> Wallet {
+        isLoading = true
+        defer { isLoading = false }
+
+        let jwkData = try FileService.shared.readJWKFile(at: fileURL)
+        let result = try await cliBridge.importFromJWK(filePath: fileURL.path, name: name)
+
+        let walletId = UUID()
+        let wallet = Wallet(
+            id: walletId,
+            name: name,
+            chain: .arweave,
+            address: result.address,
+            isImported: true,
+            derivationPath: "",
+            hasMnemonicBackup: false
+        )
+
+        try keychain.saveJWK(jwkData, forWalletId: walletId)
+
+        wallets.append(wallet)
+        saveWallets()
+        return wallet
+    }
+
+    /// Import an ICP identity from a PEM file
+    func importFromPEM(fileURL: URL, name: String) async throws -> Wallet {
+        isLoading = true
+        defer { isLoading = false }
+
+        let pemContent = try FileService.shared.readPEMFile(at: fileURL)
+        let result = try await cliBridge.importFromPEM(filePath: fileURL.path, name: name)
+
+        let walletId = UUID()
+        let wallet = Wallet(
+            id: walletId,
+            name: name,
+            chain: .icp,
+            address: result.address,
+            isImported: true,
+            derivationPath: Chain.icp.derivationPath,
+            hasMnemonicBackup: false
+        )
+
+        try keychain.savePrivateKey(pemContent, forWalletId: walletId)
+
+        wallets.append(wallet)
+        saveWallets()
+        return wallet
+    }
+
+    /// Import an Ethereum wallet from a keystore JSON
+    func importFromKeystore(fileURL: URL, password: String, name: String) async throws -> Wallet {
+        isLoading = true
+        defer { isLoading = false }
+
+        _ = try FileService.shared.readKeystoreFile(at: fileURL)
+        let result = try await cliBridge.importFromKeystore(filePath: fileURL.path, password: password, name: name)
+
+        let walletId = UUID()
+        let wallet = Wallet(
+            id: walletId,
+            name: name,
+            chain: .ethereum,
+            address: result.address,
+            isImported: true,
+            derivationPath: Chain.ethereum.derivationPath,
+            hasMnemonicBackup: false
+        )
+
+        if let privateKey = result.privateKey {
+            try keychain.savePrivateKey(privateKey, forWalletId: walletId)
+        }
+
+        wallets.append(wallet)
+        saveWallets()
+        return wallet
+    }
+
+    // MARK: - Wallet Management
+
+    /// Delete a wallet and all its associated secrets
+    func deleteWallet(_ wallet: Wallet) {
+        keychain.deleteAllSecrets(forWalletId: wallet.id)
+        wallets.removeAll { $0.id == wallet.id }
+        if selectedWalletId == wallet.id {
+            selectedWalletId = nil
+        }
+        saveWallets()
+    }
+
+    /// Rename a wallet
+    func renameWallet(_ wallet: Wallet, to newName: String) {
+        guard let index = wallets.firstIndex(where: { $0.id == wallet.id }) else { return }
+        wallets[index].name = newName
+        saveWallets()
+    }
+
+    /// Refresh balance for a single wallet
+    func refreshBalance(for wallet: Wallet) async {
+        guard let index = wallets.firstIndex(where: { $0.id == wallet.id }) else { return }
+
+        do {
+            let balance = try await cliBridge.getBalance(chain: wallet.chain, address: wallet.address)
+            wallets[index].cachedBalance = balance
+            wallets[index].balanceLastUpdated = Date()
+            saveWallets()
+        } catch {
+            // Silently fail balance refresh — don't disrupt the UI
+        }
+    }
+
+    /// Refresh balances for all wallets
+    func refreshAllBalances() async {
+        isLoading = true
+        defer { isLoading = false }
+
+        await withTaskGroup(of: Void.self) { group in
+            for wallet in wallets {
+                group.addTask { [weak self] in
+                    await self?.refreshBalance(for: wallet)
+                }
+            }
+        }
+    }
+
+    /// Check if we have the mnemonic for a given wallet
+    func hasMnemonic(for wallet: Wallet) -> Bool {
+        keychain.hasMnemonic(forWalletId: wallet.id)
+    }
+
+    /// Retrieve mnemonic for a wallet (requires confirmation)
+    func getMnemonic(for wallet: Wallet) -> String? {
+        try? keychain.getMnemonic(forWalletId: wallet.id)
+    }
+}