fix(build): resolve compilation errors in key-wallet-ffi and dash-spv

- Fixed NetworkMessage enum variant from GetMnListDiff to GetMnListD
- Removed non-existent address module import from key-wallet
- Fixed AddressType conversion to use dashcore types
- Commented out AddressGenerator as it doesn't exist in dashcore
- Added missing Error enum pattern matches
- Fixed InvalidAddress error variant usage

The build now succeeds for all main packages except dash-fuzz and key-wallet-ffi
which have deeper issues that need separate attention.

Author: dcg

key-wallet-ffi/src/key_wallet.udl

@@ -166,15 +166,16 @@ interface Address {
 };
 
 // Address generator interface
-interface AddressGenerator {
-    // Create new generator
-    constructor(Network network);
-    
-    // Generate address
-    [Throws=KeyWalletError]
-    Address generate(AccountXPub account_xpub, boolean external, u32 index);
-    
-    // Generate a range of addresses
-    [Throws=KeyWalletError]
-    sequence<Address> generate_range(AccountXPub account_xpub, boolean external, u32 start, u32 count);
-};
+// NOTE: AddressGenerator doesn't exist in dashcore, commented out for now
+// interface AddressGenerator {
+//     // Create new generator
+//     constructor(Network network);
+//     
+//     // Generate address
+//     [Throws=KeyWalletError]
+//     Address generate(AccountXPub account_xpub, boolean external, u32 index);
+//     
+//     // Generate a range of addresses
+//     [Throws=KeyWalletError]
+//     sequence<Address> generate_range(AccountXPub account_xpub, boolean external, u32 start, u32 count);
+// };

key-wallet-ffi/src/lib.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use key_wallet::{
-    self as kw, address as kw_address, derivation::HDWallet as KwHDWallet, mnemonic as kw_mnemonic,
+    self as kw, derivation::HDWallet as KwHDWallet, mnemonic as kw_mnemonic,
     DerivationPath as KwDerivationPath, ExtendedPrivKey, ExtendedPubKey, Network as KwNetwork,
 };
 use secp256k1::{PublicKey, Secp256k1};
@@ -75,20 +75,20 @@ pub enum AddressType {
     P2SH,
 }
 
-impl From<kw_address::AddressType> for AddressType {
-    fn from(t: kw_address::AddressType) -> Self {
+impl From<dashcore::AddressType> for AddressType {
+    fn from(t: dashcore::AddressType) -> Self {
         match t {
-            kw_address::AddressType::P2PKH => AddressType::P2PKH,
-            kw_address::AddressType::P2SH => AddressType::P2SH,
+            dashcore::AddressType::P2pkh => AddressType::P2PKH,
+            dashcore::AddressType::P2sh => AddressType::P2SH,
         }
     }
 }
 
-impl From<AddressType> for kw_address::AddressType {
+impl From<AddressType> for dashcore::AddressType {
     fn from(t: AddressType) -> Self {
         match t {
-            AddressType::P2PKH => kw_address::AddressType::P2PKH,
-            AddressType::P2SH => kw_address::AddressType::P2SH,
+            AddressType::P2PKH => dashcore::AddressType::P2pkh,
+            AddressType::P2SH => dashcore::AddressType::P2sh,
         }
     }
 }
@@ -189,6 +189,15 @@ impl From<kw::Error> for KeyWalletError {
             kw::Error::KeyError(msg) => KeyWalletError::KeyError {
                 message: msg,
             },
+            kw::Error::CoinJoinNotEnabled => KeyWalletError::InvalidMnemonic {
+                message: "CoinJoin not enabled".into(),
+            },
+            kw::Error::Serialization(msg) => KeyWalletError::KeyError {
+                message: msg,
+            },
+            kw::Error::InvalidParameter(msg) => KeyWalletError::InvalidDerivationPath {
+                message: msg,
+            },
         }
     }
 }
@@ -439,12 +448,14 @@ impl ExtPubKey {
 
 // Address wrapper
 pub struct Address {
-    inner: kw_address::Address,
+    inner: dashcore::Address,
 }
 
 impl Address {
     pub fn from_string(address: String, network: Network) -> Result<Self, KeyWalletError> {
-        let inner = kw_address::Address::from_str(&address).map_err(|e| KeyWalletError::from(e))?;
+        let inner = dashcore::Address::from_str(&address).map_err(|e| KeyWalletError::AddressError {
+            message: e.to_string(),
+        })?;
 
         // Validate that the parsed network matches the expected network
         // Note: Testnet, Devnet, and Regtest all share the same address prefixes (140/19)
@@ -485,7 +496,7 @@ impl Address {
             PublicKey::from_slice(&public_key).map_err(|e| KeyWalletError::Secp256k1Error {
                 message: e.to_string(),
             })?;
-        let inner = kw_address::Address::p2pkh(&pubkey, network.into());
+        let inner = dashcore::Address::p2pkh(&pubkey, network.into());
         Ok(Self {
             inner,
         })
@@ -515,72 +526,75 @@ impl Address {
 }
 
 // Address generator wrapper
-pub struct AddressGenerator {
-    inner: kw_address::AddressGenerator,
-}
-
-impl AddressGenerator {
-    pub fn new(network: Network) -> Self {
-        Self {
-            inner: kw_address::AddressGenerator::new(network.into()),
-        }
-    }
-
-    pub fn generate(
-        &self,
-        account_xpub: AccountXPub,
-        external: bool,
-        index: u32,
-    ) -> Result<Arc<Address>, KeyWalletError> {
-        // Parse the extended public key from string
-        let xpub =
-            ExtendedPubKey::from_str(&account_xpub.xpub).map_err(|e| KeyWalletError::KeyError {
-                message: e.to_string(),
-            })?;
-
-        // Generate addresses for a single index
-        let addrs = self
-            .inner
-            .generate_range(&xpub, external, index, 1)
-            .map_err(|e| KeyWalletError::from(e))?;
-
-        let addr = addrs.into_iter().next().ok_or_else(|| KeyWalletError::KeyError {
-            message: "Failed to generate address".into(),
-        })?;
-
-        Ok(Arc::new(Address {
-            inner: addr,
-        }))
-    }
-
-    pub fn generate_range(
-        &self,
-        account_xpub: AccountXPub,
-        external: bool,
-        start: u32,
-        count: u32,
-    ) -> Result<Vec<Arc<Address>>, KeyWalletError> {
-        // Parse the extended public key from string
-        let xpub =
-            ExtendedPubKey::from_str(&account_xpub.xpub).map_err(|e| KeyWalletError::KeyError {
-                message: e.to_string(),
-            })?;
-
-        let addrs = self
-            .inner
-            .generate_range(&xpub, external, start, count)
-            .map_err(|e| KeyWalletError::from(e))?;
-
-        Ok(addrs
-            .into_iter()
-            .map(|addr| {
-                Arc::new(Address {
-                    inner: addr,
-                })
-            })
-            .collect())
-    }
-}
+// NOTE: AddressGenerator doesn't exist in dashcore, commented out for now
+// pub struct AddressGenerator {
+//     inner: dashcore::address::AddressGenerator,
+// }
+
+// impl AddressGenerator {
+//     pub fn new(network: Network) -> Self {
+//         Self {
+//             inner: dashcore::address::AddressGenerator::new(network.into()),
+//         }
+//     }
+
+// AddressGenerator methods commented out since AddressGenerator doesn't exist in dashcore
+// TODO: Implement address generation functionality without AddressGenerator
+//     pub fn generate(
+//         &self,
+//         account_xpub: AccountXPub,
+//         external: bool,
+//         index: u32,
+//     ) -> Result<Arc<Address>, KeyWalletError> {
+//         // Parse the extended public key from string
+//         let xpub =
+//             ExtendedPubKey::from_str(&account_xpub.xpub).map_err(|e| KeyWalletError::KeyError {
+//                 message: e.to_string(),
+//             })?;
+//
+//         // Generate addresses for a single index
+//         let addrs = self
+//             .inner
+//             .generate_range(&xpub, external, index, 1)
+//             .map_err(|e| KeyWalletError::from(e))?;
+//
+//         let addr = addrs.into_iter().next().ok_or_else(|| KeyWalletError::KeyError {
+//             message: "Failed to generate address".into(),
+//         })?;
+//
+//         Ok(Arc::new(Address {
+//             inner: addr,
+//         }))
+//     }
+//
+//     pub fn generate_range(
+//         &self,
+//         account_xpub: AccountXPub,
+//         external: bool,
+//         start: u32,
+//         count: u32,
+//     ) -> Result<Vec<Arc<Address>>, KeyWalletError> {
+//         // Parse the extended public key from string
+//         let xpub =
+//             ExtendedPubKey::from_str(&account_xpub.xpub).map_err(|e| KeyWalletError::KeyError {
+//                 message: e.to_string(),
+//             })?;
+//
+//         let addrs = self
+//             .inner
+//             .generate_range(&xpub, external, start, count)
+//             .map_err(|e| KeyWalletError::from(e))?;
+//
+//         Ok(addrs
+//             .into_iter()
+//             .map(|addr| {
+//                 Arc::new(Address {
+//                     inner: addr,
+//                 })
+//             })
+//             .collect())
+//     }
+// }
 
 #[cfg(test)]
 mod network_compatibility_tests {