@@ -593,31 +593,6 @@ final class SwiftDashSDKHost {
         return persistedMnemonics().contains { Mnemonic.normalizePhrase($0.mnemonic) == typed }
     }
 
-    /// Throwaway key-wallet stack (manager + wallet) for path-based key
-    /// derivation, built from the persisted mnemonic of the host's active
-    /// wallet. Separate from the running `PlatformWalletManager` — key
-    /// derivation lives in the `WalletManager`/`Wallet` FFI surface, which
-    /// the runtime handles don't expose. The instances derive keys locally
-    /// (no networking, no persistence); drop them when done.
-    ///
-    /// Consumers: the masternode Owner/Voting key deriver and CrowdNode
-    /// message signing. Returns nil when no wallet is bound/running or the
-    /// mnemonic can't be read (logged).
-    func derivationWallet() -> (manager: WalletManager, wallet: Wallet, walletId: Data)? {
-        guard let hostWalletId = wallet?.walletId, let network = runningNetwork else {
-            Self.logger.warning("🪺 HOST :: derivationWallet — no bound wallet/network")
-            return nil
-        }
-        guard let mnemonic = try? WalletStorage().retrieveMnemonic(for: hostWalletId),
-              let manager = try? WalletManager(network: network),
-              let walletId = try? manager.addWallet(mnemonic: mnemonic),
-              let derivationWallet = (try? manager.getWallet(id: walletId)) ?? nil else {
-            Self.logger.error("🪺 HOST :: derivationWallet — key-wallet bootstrap failed")
-            return nil
-        }
-        return (manager: manager, wallet: derivationWallet, walletId: walletId)
-    }
-
     // MARK: - Lifecycle
 
     enum HostError: LocalizedError {
 
@@ -93,8 +93,8 @@ final class MasternodeVoterRegistry {
     /// Outcome of a votable-node resolution.
     ///
     /// `mayBeIncomplete` says the answer cannot be trusted as exhaustive: the
-    /// voting address pool was read from the degraded fallback (gap-limit
-    /// deep) *and* at least one active registration went unmatched, so a node
+    /// voting address pool could not be read from the running wallet *and*
+    /// at least one active registration went unmatched, so a node
     /// this wallet really can vote with may be missing from `nodes`. The UI
     /// says so rather than presenting a short list as the full picture.
     struct Resolution {
@@ -163,8 +163,8 @@ final class MasternodeVoterRegistry {
                     keySource: .walletIndex(index))
             }
 
-        // Only a degraded pool read can hide a node we own; if every active
-        // registration matched, depth did not matter.
+        // Only an unread pool can hide a node we own. If every active
+        // registration matched, the pool did not matter.
         let mayBeIncomplete = !resolution.poolIsLive && nodes.count < eligible.count
         Self.logger.info(
             "🗳️ VOTING :: votable nodes=\(nodes.count, privacy: .public) of \(eligible.count, privacy: .public) active registrations livePool=\(resolution.poolIsLive, privacy: .public)")
 
@@ -185,11 +185,11 @@ extension DerivationPathKeysModel {
 /// Derives masternode provider Owner/Voting keys (ECDSA) from SwiftDashSDK,
 /// replacing DashSync's `DSAuthenticationKeysDerivationPath`.
 ///
-/// The DIP-3 paths — voting `m/9'/<coin>'/3'/1'`, owner `m/9'/<coin>'/3'/2'`
-/// (ECDSA, fully hardened account path, soft key index; coin = 5' mainnet /
-/// 1' testnet) — are resolved Rust-side by `providerKeyAtIndex`. They are NOT
-/// rebuilt here: composing them app-side is what let the account path be
-/// applied twice and produced keys off the intended branch.
+/// The DIP-3 voting and owner account paths (ECDSA, fully hardened account
+/// path, soft key index) are resolved Rust-side: `providerKeyAtIndex` derives
+/// every private key, and the addresses come from the running wallet's pool.
+/// Composing the account path app-side is what let it be applied twice and
+/// produced keys off the intended branch.
 ///
 /// Internal (not private): `MasternodeKeyUsage` reuses `address(at:)` for
 /// its owner/voting address join.
@@ -206,32 +206,17 @@ final class MasternodeProviderKeyDeriver {
     /// resolver the operator/platform families use — not a second copy of it.
     private let keyResolver: ProviderKeyResolver
 
-    /// Index → base58 address of the provider pool, snapshotted once at init.
-    /// Sourced from the running wallet (`loadLiveAddresses`), falling back to
-    /// the derivation wallet's own pool (`loadDerivationAddresses`) when the
-    /// running wallet has no provider account yet — e.g. a just-imported
-    /// wallet whose registration hasn't completed. Empty only when neither
-    /// source has a pool, in which case there are genuinely no addresses to
-    /// join against.
+    /// Index → base58 address of the running wallet's provider pool,
+    /// snapshotted once at init. Empty when the wallet has no provider account
+    /// yet, such as a just-imported wallet whose registration hasn't completed.
     private let poolAddresses: [UInt32: String]
 
     init?(key: MNKey) {
-        // The network itself is no longer read here — it selected the coin
-        // type when this class composed the DIP-3 path app-side. The resolver
-        // owns that now; the check remains because a host with no running
-        // network has no wallet to derive from either.
-        guard SwiftDashSDKHost.shared.runningNetwork != nil else {
-            return nil
-        }
-
-        let type: AccountType
         let kind: ManagedPlatformWallet.ProviderKeyKind
         switch key {
         case .voting:
-            type = .providerVotingKeys
             kind = .votingECDSA
         case .owner:
-            type = .providerOwnerKeys
             kind = .ownerECDSA
         case .operator, .evonodeOperator:
             // BLS / Ed25519 families have no address rows, so they use
@@ -243,41 +228,18 @@ final class MasternodeProviderKeyDeriver {
             return nil
         }
 
-        // The derivation stack is a THROWAWAY key-wallet built from the
-        // mnemonic (see `SwiftDashSDKHost.derivationWallet`) — it has never
-        // processed a transaction, so its pools sit at the freshly-created
-        // `DEFAULT_SPECIAL_GAP_LIMIT` depth. It backs ONLY the fallback
-        // address pool below; private keys come from `keyResolver`. Nothing
-        // outlives this initializer: the wallet is owned by `derivationManager`,
-        // which is released on return, so holding either past the pool read
-        // would leave a reference into a freed graph.
-        guard let (derivationManager, wallet, derivationWalletId) =
-                SwiftDashSDKHost.shared.derivationWallet() else {
-            return nil
-        }
-
-        // Ensure the provider account exists so the fallback pool read below
-        // can resolve it.
-        _ = try? wallet.getAccount(type: type)
-
+        self.poolAddresses = Self.loadLiveAddresses(for: key)
         self.keyResolver = keyResolver
-
-        let live = Self.loadLiveAddresses(for: key)
-        self.poolIsLive = !live.isEmpty
-        self.poolAddresses = live.isEmpty
-            ? Self.loadDerivationAddresses(
-                key: key, manager: derivationManager, walletId: derivationWalletId)
-            : live
+        self.poolIsLive = !poolAddresses.isEmpty
     }
 
-    /// `true` when ``poolAddresses`` came from the running wallet's live pool.
+    /// `true` when the running wallet had a provider pool to read.
     ///
-    /// `false` means the degraded derivation-wallet fallback, which only ever
-    /// holds `DEFAULT_SPECIAL_GAP_LIMIT` entries. Consumers that merely *look
-    /// up* an index are unaffected, but consumers that **enumerate** the pool
-    /// to decide what exists — the owner/voting address joins — can silently
-    /// under-report, so they must surface the incompleteness rather than
-    /// present a short list as the whole truth.
+    /// `false` means ``poolAddresses`` is empty. Consumers that merely *look
+    /// up* an index find nothing, and consumers that **enumerate** the pool
+    /// to decide what exists — the owner/voting address joins — must surface
+    /// that the answer may be incomplete rather than present an empty list as
+    /// the whole truth.
     let poolIsLive: Bool
 
     /// Snapshot the running wallet's provider address pool — the one SPV
@@ -306,47 +268,6 @@ final class MasternodeProviderKeyDeriver {
         return addresses
     }
 
-    /// Degraded-path pool read from the derivation wallet itself, used when
-    /// the running wallet can't vend the account. This stack never processes
-    /// transactions, so its pool is only ever the freshly-created
-    /// `DEFAULT_SPECIAL_GAP_LIMIT` depth — enough to keep the low indexes
-    /// resolvable rather than showing nothing at all, but it is NOT a
-    /// substitute for the live pool (that shallowness is precisely the bug
-    /// this class's live read exists to fix).
-    private static func loadDerivationAddresses(
-        key: MNKey,
-        manager: WalletManager,
-        walletId: Data
-    ) -> [UInt32: String] {
-        guard let collection = manager.getManagedAccountCollection(walletId: walletId) else {
-            return [:]
-        }
-        let account: ManagedAccount?
-        switch key {
-        case .voting: account = collection.getProviderVotingKeysAccount()
-        case .owner: account = collection.getProviderOwnerKeysAccount()
-        case .operator, .evonodeOperator: account = nil
-        }
-        guard let pool = account?.getAddressPool(type: .single)
-                ?? account?.getExternalAddressPool() else {
-            return [:]
-        }
-
-        // The pool exposes no count, so walk until it stops vending. The cap
-        // is a runaway guard, not a semantic window: this pool is created at
-        // gap-limit depth and never grows here.
-        var addresses: [UInt32: String] = [:]
-        for index in 0..<Self.derivationPoolProbeCap {
-            guard let info = try? pool.getAddress(at: index) else { break }
-            addresses[index] = info.address
-        }
-        return addresses
-    }
-
-    /// Runaway guard for the fallback pool walk — far above any gap-limit
-    /// depth the derivation wallet can hold.
-    private static let derivationPoolProbeCap: UInt32 = 200
-
     func wif(at index: UInt32) -> String? {
         keyResolver.key(at: index)?.privateKeyWIF
     }
@@ -355,11 +276,7 @@ final class MasternodeProviderKeyDeriver {
         keyResolver.key(at: index)?.privateKeyHex
     }
 
-    /// The pool address at `index`. Backed by the running wallet's live pool
-    /// whenever it's available: reading the throwaway derivation wallet as
-    /// the primary source would cap every consumer at that stack's initial
-    /// 5-entry pool, hiding every masternode whose owner/voting key sits at
-    /// a deeper index.
+    /// The address at `index` of the running wallet's provider pool.
     func address(at index: UInt32) -> String? {
         poolAddresses[index]
     }
 
@@ -165,11 +165,10 @@ struct MasternodeKeyUsage {
 
     /// The address join plus whether it was made against the complete pool.
     ///
-    /// `poolIsLive == false` means the derivation-wallet fallback answered,
-    /// and that pool is only gap-limit deep — so an address that is genuinely
-    /// ours but sits at a deeper index is simply not in `map`. Callers that
-    /// present the result as "these are all of them" must say so; a caller
-    /// that only labels known rows can ignore it.
+    /// `poolIsLive == false` means the running wallet had no provider pool to
+    /// read, so an address that is genuinely ours is missing from `map`.
+    /// Callers that present the result as "these are all of them" must say
+    /// so; a caller that only labels known rows can ignore it.
     static func resolveAddressIndexes(
         family: MNKey,
         targets: Set<String>