agentvault 1.0.2 → 1.0.5

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

@@ -1,137 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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)
-    }
-}