Merge rust-bitcoin/rust-bitcoin#6809: addresses: Add `AddressParams` type and remove most uses of network types

### addresses/src/error.rs
@@ -6,13 +6,11 @@ use core::fmt;
 use internals::error::InputString;
 use internals::write_err;
 #[cfg(feature = "alloc")]
-use network::Network;
-#[cfg(feature = "alloc")]
 use primitives::witness_version;
 
 use crate::witness_program;
 #[cfg(feature = "alloc")]
-use crate::{Address, NetworkUnchecked};
+use crate::{Address, AddressParams, NetworkUnchecked};
 
 /// Error while generating address from script.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -131,8 +129,8 @@ impl std::error::Error for UnknownHrpError {
 #[cfg(feature = "alloc")]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct NetworkValidationError {
-    /// Network that was required.
-    pub(crate) required: Network,
+    /// Address parameters that were required.
+    pub(crate) required: AddressParams,
     /// The address itself.
     pub(crate) address: Address<NetworkUnchecked>,
 }

### addresses/src/lib.rs
@@ -40,15 +40,14 @@
 //! {
 //! use bitcoin_crypto::secp256k1::rand;
 //! use bitcoin_crypto::key::LegacyPublicKey;
-//! use network::Network;
-//! use bitcoin_addresses::Address;
+//! use bitcoin_addresses::{Address, AddressParams};
 //!
 //! // Generate random key pair.
 //! let (_sk, pk) = secp256k1::generate_keypair(&mut rand::rng());
 //! let public_key = LegacyPublicKey::from_secp(pk); // Or `LegacyPublicKey::from(pk)`.
 //!
 //! // Generate a mainnet pay-to-pubkey-hash address.
-//! let address = Address::p2pkh(&public_key, Network::Bitcoin);
+//! let address = Address::p2pkh(&public_key, AddressParams::MAINNET);
 //! }
 //! ```
 //!
@@ -125,7 +124,7 @@ use crypto::key::{
 };
 use hashes::{hash160, HashEngine};
 use internals::array::ArrayExt as _;
-use network::{Network, NetworkKind};
+use network::NetworkKind;
 #[cfg(feature = "alloc")]
 use primitives::opcodes::all::{OP_CHECKSIG, OP_DUP, OP_EQUALVERIFY, OP_HASH160};
 #[cfg(feature = "alloc")]
@@ -387,15 +386,6 @@ pub enum KnownHrp {
 }
 
 impl KnownHrp {
-    /// Constructs a new [`KnownHrp`] from [`Network`].
-    fn from_network(network: Network) -> Self {
-        match network {
-            Network::Bitcoin => Self::Mainnet,
-            Network::Testnet(_) | Network::Signet => Self::Testnets,
-            Network::Regtest => Self::Regtest,
-        }
-    }
-
     /// Constructs a new [`KnownHrp`] from a [`bech32::Hrp`].
     #[cfg(feature = "alloc")]
     fn from_hrp(hrp: Hrp) -> Result<Self, UnknownHrpError> {
@@ -418,19 +408,51 @@ impl KnownHrp {
             Self::Regtest => bech32::hrp::BCRT,
         }
     }
+
+    /// Converts this to a [`NetworkKind`].
+    fn to_network_kind(self) -> NetworkKind {
+        match self {
+            Self::Mainnet => NetworkKind::Main,
+            Self::Testnets => NetworkKind::Test,
+            Self::Regtest => NetworkKind::Test,
+        }
+    }
 }
 
-impl From<Network> for KnownHrp {
-    fn from(n: Network) -> Self { Self::from_network(n) }
+/// Parameters that define how an [`Address`] is serialized.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct AddressParams {
+    /// Determines the version byte prefixed to legacy (base58) addresses.
+    network_kind: NetworkKind,
+    /// Determines the hrp of SegWit (bech32) addresses.
+    hrp: KnownHrp,
 }
 
-impl From<KnownHrp> for NetworkKind {
-    fn from(hrp: KnownHrp) -> Self {
-        match hrp {
-            KnownHrp::Mainnet => Self::Main,
-            KnownHrp::Testnets => Self::Test,
-            KnownHrp::Regtest => Self::Test,
-        }
+impl AddressParams {
+    /// The address parameters of the main Bitcoin network.
+    pub const MAINNET: Self = Self { network_kind: NetworkKind::Main, hrp: KnownHrp::Mainnet };
+
+    /// The address parameters of the testnet3 network.
+    pub const TESTNET3: Self = Self { network_kind: NetworkKind::Test, hrp: KnownHrp::Testnets };
+
+    /// The address parameters of the testnet4 network.
+    pub const TESTNET4: Self = Self { network_kind: NetworkKind::Test, hrp: KnownHrp::Testnets };
+
+    /// The address parameters of the signet network.
+    pub const SIGNET: Self = Self { network_kind: NetworkKind::Test, hrp: KnownHrp::Testnets };
+
+    /// The address parameters of the regtest network.
+    pub const REGTEST: Self = Self { network_kind: NetworkKind::Test, hrp: KnownHrp::Regtest };
+}
+
+impl fmt::Display for AddressParams {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let s = match self.hrp {
+            KnownHrp::Mainnet => "mainnet",
+            KnownHrp::Testnets => "testnet or signet",
+            KnownHrp::Regtest => "regtest",
+        };
+        f.write_str(s)
     }
 }
 
@@ -481,20 +503,19 @@ transparent_newtype! {
     /// ```rust
     /// # #[cfg(feature = "alloc")] {
     /// use std::str::FromStr;
-    /// use bitcoin_addresses::{Address, NetworkUnchecked, NetworkChecked};
-    /// use bitcoin_addresses::network::Network;
+    /// use bitcoin_addresses::{Address, AddressParams, NetworkUnchecked, NetworkChecked};
     ///
     /// // variant 1
     /// let address: Address<NetworkUnchecked> = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse().unwrap();
-    /// let _address: Address<NetworkChecked> = address.require_network(Network::Bitcoin).unwrap();
+    /// let _address: Address<NetworkChecked> = address.require_network(AddressParams::MAINNET).unwrap();
     ///
     /// // variant 2
     /// let _address: Address = Address::from_str("32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf").unwrap()
-    ///                .require_network(Network::Bitcoin).unwrap();
+    ///                .require_network(AddressParams::MAINNET).unwrap();
     ///
     /// // variant 3
     /// let _address: Address<NetworkChecked> = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse::<Address<_>>()
-    ///                .unwrap().require_network(Network::Bitcoin).unwrap();
+    ///                .unwrap().require_network(AddressParams::MAINNET).unwrap();
     /// # }
     /// ```
     ///
@@ -646,7 +667,7 @@ impl<V: NetworkValidation> Address<V> {
         match *self.inner() {
             AddressInner::P2pkh { hash: _, ref network } => *network,
             AddressInner::P2sh { hash: _, ref network } => *network,
-            AddressInner::Segwit { program: _, ref hrp } => NetworkKind::from(*hrp),
+            AddressInner::Segwit { program: _, ref hrp } => (*hrp).to_network_kind(),
         }
     }
 }
@@ -657,9 +678,10 @@ impl Address {
     ///
     /// This is the preferred non-witness type address.
     #[inline]
-    pub fn p2pkh(pk: impl Into<PubkeyHash>, network: impl Into<NetworkKind>) -> Self {
+    pub fn p2pkh(pk: impl Into<PubkeyHash>, params: impl Into<AddressParams>) -> Self {
         let hash = pk.into();
-        Self::from_inner(AddressInner::P2pkh { hash, network: network.into() })
+        let network = params.into().network_kind;
+        Self::from_inner(AddressInner::P2pkh { hash, network })
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] from a script.
@@ -674,10 +696,10 @@ impl Address {
     #[cfg(feature = "alloc")]
     pub fn p2sh<T: ScriptHashableTag>(
         redeem_script: &Script<T>,
-        network: impl Into<NetworkKind>,
+        params: impl Into<AddressParams>,
     ) -> Result<Self, RedeemScriptSizeError> {
         let hash = redeem_script.script_hash()?;
-        Ok(Self::p2sh_from_hash(hash, network))
+        Ok(Self::p2sh_from_hash(hash, params))
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] from a script hash.
@@ -686,16 +708,17 @@ impl Address {
     ///
     /// The `hash` pre-image (redeem script) must not exceed 520 bytes in length
     /// otherwise outputs created from the returned address will be un-spendable.
-    pub fn p2sh_from_hash(hash: ScriptHash, network: impl Into<NetworkKind>) -> Self {
-        Self::from_inner(AddressInner::P2sh { hash, network: network.into() })
+    pub fn p2sh_from_hash(hash: ScriptHash, params: impl Into<AddressParams>) -> Self {
+        let network = params.into().network_kind;
+        Self::from_inner(AddressInner::P2sh { hash, network })
     }
 
     /// Constructs a new pay-to-witness-public-key-hash (P2WPKH) [`Address`] from a public key.
     ///
     /// This is the native SegWit address type for an output redeemable with a single signature.
-    pub fn p2wpkh(pk: FullPublicKey, hrp: impl Into<KnownHrp>) -> Self {
+    pub fn p2wpkh(pk: FullPublicKey, params: impl Into<AddressParams>) -> Self {
         let program = WitnessProgram::p2wpkh(pk);
-        Self::from_witness_program(program, hrp)
+        Self::from_witness_program(program, params)
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] that embeds a
@@ -704,11 +727,11 @@ impl Address {
     /// This is a SegWit address type that looks familiar (as p2sh) to legacy clients.
     #[allow(clippy::missing_panics_doc)] // script cannot cause hash failure due to size
     #[cfg(feature = "alloc")]
-    pub fn p2shwpkh(pk: FullPublicKey, network: impl Into<NetworkKind>) -> Self {
+    pub fn p2shwpkh(pk: FullPublicKey, params: impl Into<AddressParams>) -> Self {
         let builder =
             ScriptPubKey::builder().push_opcode(OP_PUSHBYTES_0).push_slice(pk.wpubkey_hash());
         let script_hash = builder.as_script().script_hash().expect("script is less than 520 bytes");
-        Self::p2sh_from_hash(script_hash, network)
+        Self::p2sh_from_hash(script_hash, params)
     }
 
     /// Constructs a new pay-to-witness-script-hash (P2WSH) [`Address`] from a witness script.
@@ -719,16 +742,16 @@ impl Address {
     #[cfg(feature = "alloc")]
     pub fn p2wsh(
         witness_script: &WitnessScript,
-        hrp: impl Into<KnownHrp>,
+        params: impl Into<AddressParams>,
     ) -> Result<Self, WitnessScriptSizeError> {
         let program = WitnessProgram::p2wsh(witness_script)?;
-        Ok(Self::from_witness_program(program, hrp))
+        Ok(Self::from_witness_program(program, params))
     }
 
     /// Constructs a new pay-to-witness-script-hash (P2WSH) [`Address`] from a witness script hash.
-    pub fn p2wsh_from_hash(hash: WScriptHash, hrp: impl Into<KnownHrp>) -> Self {
+    pub fn p2wsh_from_hash(hash: WScriptHash, params: impl Into<AddressParams>) -> Self {
         let program = WitnessProgram::p2wsh_from_hash(hash);
-        Self::from_witness_program(program, hrp)
+        Self::from_witness_program(program, params)
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] that embeds a
@@ -743,42 +766,42 @@ impl Address {
     #[cfg(feature = "alloc")]
     pub fn p2shwsh(
         witness_script: &WitnessScript,
-        network: impl Into<NetworkKind>,
+        params: impl Into<AddressParams>,
     ) -> Result<Self, WitnessScriptSizeError> {
         let hash = witness_script.wscript_hash()?;
         let builder = ScriptPubKey::builder().push_opcode(OP_PUSHBYTES_0).push_slice(hash);
         let script_hash = builder.as_script().script_hash().expect("script is less than 520 bytes");
-        Ok(Self::p2sh_from_hash(script_hash, network))
+        Ok(Self::p2sh_from_hash(script_hash, params))
     }
 
     /// Constructs a new pay-to-Taproot (P2TR) [`Address`] from an untweaked key.
     pub fn p2tr<K: Into<UntweakedPublicKey>>(
         internal_key: K,
         merkle_root: Option<TapNodeHash>,
-        hrp: impl Into<KnownHrp>,
+        params: impl Into<AddressParams>,
     ) -> Self {
         let internal_key = internal_key.into();
         let program = WitnessProgram::p2tr(internal_key, merkle_root);
-        Self::from_witness_program(program, hrp)
+        Self::from_witness_program(program, params)
     }
 
     /// Constructs a new pay-to-Taproot (P2TR) [`Address`] from a tweaked output key.
-    pub fn p2tr_tweaked(output_key: TweakedPublicKey, hrp: impl Into<KnownHrp>) -> Self {
+    pub fn p2tr_tweaked(output_key: TweakedPublicKey, params: impl Into<AddressParams>) -> Self {
         let program = WitnessProgram::p2tr_tweaked(output_key);
-        Self::from_witness_program(program, hrp)
+        Self::from_witness_program(program, params)
     }
 
     /// Constructs a new pay-to-anchor (P2A) [`Address`].
-    pub fn p2a(hrp: impl Into<KnownHrp>) -> Self {
-        Self::from_witness_program(WitnessProgram::p2a(), hrp)
+    pub fn p2a(params: impl Into<AddressParams>) -> Self {
+        Self::from_witness_program(WitnessProgram::p2a(), params)
     }
 
     /// Constructs a new [`Address`] from an arbitrary [`WitnessProgram`].
     ///
     /// This only exists to support future witness versions. If you are doing normal mainnet things
     /// then you likely do not need this constructor.
-    pub fn from_witness_program(program: WitnessProgram, hrp: impl Into<KnownHrp>) -> Self {
-        let inner = AddressInner::Segwit { program, hrp: hrp.into() };
+    pub fn from_witness_program(program: WitnessProgram, params: impl Into<AddressParams>) -> Self {
+        let inner = AddressInner::Segwit { program, hrp: params.into().hrp };
         Self::from_inner(inner)
     }
 
@@ -974,26 +997,27 @@ impl Address<NetworkUnchecked> {
     ///
     /// ```rust
     /// # #[cfg(feature = "alloc")] {
-    /// use network::{Network, TestnetVersion};
-    /// use bitcoin_addresses::{Address, NetworkUnchecked};
+    /// use network::{TestnetVersion};
+    /// use bitcoin_addresses::{Address, AddressParams, NetworkUnchecked};
     ///
     /// let address: Address<NetworkUnchecked> = "2N83imGV3gPwBzKJQvWJ7cRUY2SpUyU6A5e".parse().unwrap();
-    /// assert!(address.is_valid_for_network(Network::Testnet(TestnetVersion::V3)));
-    /// assert!(address.is_valid_for_network(Network::Regtest));
-    /// assert!(address.is_valid_for_network(Network::Signet));
+    /// assert!(address.is_valid_for_network(AddressParams::TESTNET3));
+    /// assert!(address.is_valid_for_network(AddressParams::REGTEST));
+    /// assert!(address.is_valid_for_network(AddressParams::SIGNET));
     ///
-    /// assert_eq!(address.is_valid_for_network(Network::Bitcoin), false);
+    /// assert_eq!(address.is_valid_for_network(AddressParams::MAINNET), false);
     ///
     /// let address: Address<NetworkUnchecked> = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse().unwrap();
-    /// assert!(address.is_valid_for_network(Network::Bitcoin));
-    /// assert_eq!(address.is_valid_for_network(Network::Testnet(TestnetVersion::V4)), false);
+    /// assert!(address.is_valid_for_network(AddressParams::MAINNET));
+    /// assert_eq!(address.is_valid_for_network(AddressParams::TESTNET4), false);
     /// # }
     /// ```
-    pub fn is_valid_for_network(&self, n: Network) -> bool {
+    pub fn is_valid_for_network(&self, params: impl Into<AddressParams>) -> bool {
+        let params = params.into();
         match *self.inner() {
-            AddressInner::P2pkh { hash: _, ref network } => *network == NetworkKind::from(n),
-            AddressInner::P2sh { hash: _, ref network } => *network == NetworkKind::from(n),
-            AddressInner::Segwit { program: _, ref hrp } => *hrp == KnownHrp::from_network(n),
+            AddressInner::P2pkh { hash: _, ref network } => *network == params.network_kind,
+            AddressInner::P2sh { hash: _, ref network } => *network == params.network_kind,
+            AddressInner::Segwit { program: _, ref hrp } => *hrp == params.hrp,
         }
     }
 
@@ -1011,37 +1035,40 @@ impl Address<NetworkUnchecked> {
     ///  # Examples
     ///
     /// ```
-    /// use bitcoin_addresses::{Address, NetworkChecked, NetworkUnchecked, ParseError};
-    /// use network::Network;
+    /// use bitcoin_addresses::{Address, AddressParams, NetworkChecked, NetworkUnchecked, ParseError};
     ///
     /// const ADDR: &str = "bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs";
     ///
-    /// fn parse_and_validate_address(network: Network) -> Result<Address, ParseError> {
+    /// fn parse_and_validate_address(params: AddressParams) -> Result<Address, ParseError> {
     ///     let address = ADDR.parse::<Address<_>>()?
-    ///                       .require_network(network)?;
+    ///                       .require_network(params)?;
     ///     Ok(address)
     /// }
     ///
-    /// fn parse_and_validate_address_combinator(network: Network) -> Result<Address, ParseError> {
+    /// fn parse_and_validate_address_combinator(params: AddressParams) -> Result<Address, ParseError> {
     ///     let address = ADDR.parse::<Address<_>>()
-    ///                       .and_then(|a| a.require_network(network))?;
+    ///                       .and_then(|a| a.require_network(params))?;
     ///     Ok(address)
     /// }
     ///
-    /// fn parse_and_validate_address_show_types(network: Network) -> Result<Address, ParseError> {
+    /// fn parse_and_validate_address_show_types(params: AddressParams) -> Result<Address, ParseError> {
     ///     let address: Address<NetworkChecked> = ADDR.parse::<Address<NetworkUnchecked>>()?
-    ///                                                .require_network(network)?;
+    ///                                                .require_network(params)?;
     ///     Ok(address)
     /// }
     ///
-    /// let network = Network::Bitcoin;  // Don't hard code network in applications.
-    /// let _ = parse_and_validate_address(network).unwrap();
-    /// let _ = parse_and_validate_address_combinator(network).unwrap();
-    /// let _ = parse_and_validate_address_show_types(network).unwrap();
+    /// let params = AddressParams::MAINNET;  // Don't hard code network in applications.
+    /// let _ = parse_and_validate_address(params).unwrap();
+    /// let _ = parse_and_validate_address_combinator(params).unwrap();
+    /// let _ = parse_and_validate_address_show_types(params).unwrap();
     /// ```
     #[inline]
     #[cfg(feature = "alloc")]
-    pub fn require_network(self, required: Network) -> Result<Address, ParseError> {
+    pub fn require_network(
+        self,
+        required: impl Into<AddressParams>,
+    ) -> Result<Address, ParseError> {
+        let required = required.into();
         if self.is_valid_for_network(required) {
             Ok(self.assume_checked())
         } else {
@@ -1224,15 +1251,14 @@ include!("../include/newtype.rs"); // Explained in `REPO_DIR/docs/README.md`.
 #[cfg(feature = "alloc")]
 #[cfg(test)]
 mod tests {
-    use network::TestnetVersion;
     use primitives::RedeemScriptBuf;
 
     use super::*;
 
     #[test]
     fn p2sh_parse_for_large_script() {
         let script = RedeemScriptBuf::from_hex_no_length_prefix("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123").unwrap();
-        let res = Address::p2sh(&script, NetworkKind::Test);
+        let res = Address::p2sh(&script, AddressParams::TESTNET3);
         assert_eq!(res.unwrap_err().invalid_size(), script.len());
     }
 
@@ -1284,7 +1310,7 @@ mod tests {
             let addr = address
                 .parse::<Address<_>>()
                 .unwrap()
-                .require_network(Network::Bitcoin)
+                .require_network(AddressParams::MAINNET)
                 .expect("mainnet");
             assert_eq!(&addr.address_type(), expected_type);
         }
@@ -1296,7 +1322,7 @@ mod tests {
             let addr = el
                 .parse::<Address<_>>()
                 .unwrap()
-                .require_network(Network::Bitcoin)
+                .require_network(AddressParams::MAINNET)
                 .expect("mainnet");
             assert_eq!(addr.to_qr_uri(), format!("bitcoin:{}", el));
         }
@@ -1316,7 +1342,7 @@ mod tests {
         let address = address_string
             .parse::<Address<_>>()
             .expect("address")
-            .require_network(Network::Bitcoin)
+            .require_network(AddressParams::MAINNET)
             .expect("mainnet");
 
         let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
@@ -1337,7 +1363,7 @@ mod tests {
         let address = address_string
             .parse::<Address<_>>()
             .expect("address")
-            .require_network(Network::Bitcoin)
+            .require_network(AddressParams::MAINNET)
             .expect("mainnet");
 
         let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
@@ -1358,7 +1384,7 @@ mod tests {
         let address = address_string
             .parse::<Address<_>>()
             .expect("address")
-            .require_network(Network::Bitcoin)
+            .require_network(AddressParams::MAINNET)
             .expect("mainnet");
 
         let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
@@ -1379,7 +1405,7 @@ mod tests {
         let address = address_string
             .parse::<Address<_>>()
             .expect("address")
-            .require_network(Network::Testnet(TestnetVersion::V3))
+            .require_network(AddressParams::TESTNET3)
             .expect("testnet");
 
         let pubkey_string = "04e96e22004e3db93530de27ccddfdf1463975d2138ac018fc3e7ba1a2e5e0aad8e424d0b55e2436eb1d0dcd5cb2b8bcc6d53412c22f358de57803a6a655fbbd04";
@@ -1400,14 +1426,14 @@ mod tests {
         let pubkey = pubkey_string.parse::<LegacyPublicKey>().expect("pubkey");
         let xonly_pubkey = XOnlyPublicKey::from(pubkey);
         let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(xonly_pubkey);
-        let address = Address::p2tr_tweaked(tweaked_pubkey, KnownHrp::Mainnet);
+        let address = Address::p2tr_tweaked(tweaked_pubkey, AddressParams::MAINNET);
 
         assert_eq!(
             address,
             "bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e"
                 .parse::<Address<_>>()
                 .expect("address")
-                .require_network(Network::Bitcoin)
+                .require_network(AddressParams::MAINNET)
                 .expect("mainnet")
         );
 
@@ -1426,14 +1452,14 @@ mod tests {
         let pubkey = pubkey_string.parse::<LegacyPublicKey>().expect("pubkey");
         let xonly_pubkey = XOnlyPublicKey::from(pubkey);
         let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(xonly_pubkey);
-        let address = Address::p2tr_tweaked(tweaked_pubkey, KnownHrp::Mainnet);
+        let address = Address::p2tr_tweaked(tweaked_pubkey, AddressParams::MAINNET);
 
         assert_eq!(
             address,
             "bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e"
                 .parse::<Address<_>>()
                 .expect("address")
-                .require_network(Network::Bitcoin)
+                .require_network(AddressParams::MAINNET)
                 .expect("mainnet")
         );
 

### bitcoin/embedded/src/main.rs
@@ -11,7 +11,7 @@ use core::panic::PanicInfo;
 
 use alloc_cortex_m::CortexMHeap;
 // use panic_halt as _;
-use bitcoin::{Address, Network, WifKey};
+use bitcoin::{Address, AddressParams, WifKey};
 use cortex_m_rt::entry;
 use cortex_m_semihosting::{debug, hprintln};
 
@@ -34,7 +34,7 @@ fn main() -> ! {
 
     // Derive address
     let pubkey = wk.private_key.to_public_key().try_into().unwrap();
-    let address = Address::p2wpkh(pubkey, Network::Bitcoin);
+    let address = Address::p2wpkh(pubkey, AddressParams::MAINNET);
     hprintln!("Address: {}", address).unwrap();
 
     assert_eq!(address.to_string(), "bc1qpx9t9pzzl4qsydmhyt6ctrxxjd4ep549np9993");

### bitcoin/examples/bip32.rs
@@ -1,6 +1,6 @@
 use std::env;
 
-use bitcoin::address::{Address, KnownHrp};
+use bitcoin::address::{Address, AddressParams};
 use bitcoin::bip32::{ChildNumber, RelativeDerivationPath, Xpriv, Xpub};
 use bitcoin::{hex, FullPublicKey, NetworkKind};
 
@@ -39,6 +39,6 @@ fn main() {
     // manually creating indexes this time
     let zero = ChildNumber::ZERO_NORMAL;
     let public_key = xpub.derive_from_path([zero, zero]).unwrap().public_key;
-    let address = Address::p2wpkh(FullPublicKey::from_secp(public_key), KnownHrp::Mainnet);
+    let address = Address::p2wpkh(FullPublicKey::from_secp(public_key), AddressParams::MAINNET);
     println!("First receiving address: {address}");
 }

### bitcoin/examples/create-p2wpkh-address.rs
@@ -1,5 +1,5 @@
 use bitcoin::secp256k1::rand;
-use bitcoin::{Address, FullPublicKey, Network};
+use bitcoin::{Address, AddressParams, FullPublicKey};
 
 /// Generate a P2WPKH (pay-to-witness-public-key-hash) address and print it.
 fn main() {
@@ -10,7 +10,7 @@ fn main() {
     let public_key = FullPublicKey::from_secp(public_key);
 
     // Create a Bitcoin P2WPKH address.
-    let address = Address::p2wpkh(public_key, Network::Bitcoin);
+    let address = Address::p2wpkh(public_key, AddressParams::MAINNET);
 
     println!("Address: {address}");
 }

### bitcoin/examples/sign-tx-segwit-v0.rs
@@ -7,8 +7,8 @@ use bitcoin::key::WPubkeyHash;
 use bitcoin::locktime::absolute;
 use bitcoin::sighash::{EcdsaSighashType, SighashCache};
 use bitcoin::{
-    transaction, Address, Amount, Network, OutPoint, PrivateKey, ScriptPubKeyBuf, ScriptSigBuf,
-    Sequence, Transaction, TxIn, TxOut, Txid, Witness,
+    transaction, Address, AddressParams, Amount, OutPoint, PrivateKey, ScriptPubKeyBuf,
+    ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Txid, Witness,
 };
 
 const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_u32(20_000_000);
@@ -99,7 +99,7 @@ fn receivers_address() -> Address {
     "bc1q7cyrfmck2ffu2ud3rn5l5a8yv6f0chkp0zpemf"
         .parse::<Address<_>>()
         .expect("a valid address")
-        .require_network(Network::Bitcoin)
+        .require_network(AddressParams::MAINNET)
         .expect("valid address for mainnet")
 }
 

### bitcoin/examples/sign-tx-taproot.rs
@@ -7,7 +7,7 @@ use bitcoin::key::{Keypair, PrivateKey, TapTweak, TweakedKeypair, UntweakedPubli
 use bitcoin::locktime::absolute;
 use bitcoin::sighash::{Prevouts, SighashCache, TapSighashType};
 use bitcoin::{
-    transaction, Address, Amount, Network, OutPoint, ScriptPubKeyBuf, ScriptSigBuf, Sequence,
+    transaction, Address, AddressParams, Amount, OutPoint, ScriptPubKeyBuf, ScriptSigBuf, Sequence,
     Transaction, TxIn, TxOut, Txid, Witness,
 };
 
@@ -93,7 +93,7 @@ fn receivers_address() -> Address {
     "bc1p0dq0tzg2r780hldthn5mrznmpxsxc0jux5f20fwj0z3wqxxk6fpqm7q0va"
         .parse::<Address<_>>()
         .expect("a valid address")
-        .require_network(Network::Bitcoin)
+        .require_network(AddressParams::MAINNET)
         .expect("valid address for mainnet")
 }
 

### bitcoin/src/address.rs
@@ -13,14 +13,14 @@
 //! #[cfg(feature = "std")]
 //! {
 //! use bitcoin::secp256k1::rand;
-//! use bitcoin::{Address, Network, LegacyPublicKey};
+//! use bitcoin::{Address, AddressParams, LegacyPublicKey};
 //!
 //! // Generate random key pair.
 //! let (_sk, pk) = secp256k1::generate_keypair(&mut rand::rng());
 //! let public_key = LegacyPublicKey::from_secp(pk); // Or `LegacyPublicKey::from(pk)`.
 //!
 //! // Generate a mainnet pay-to-pubkey-hash address.
-//! let address = Address::p2pkh(&public_key, Network::Bitcoin);
+//! let address = Address::p2pkh(&public_key, AddressParams::MAINNET);
 //! }
 //! ```
 //!
@@ -42,6 +42,7 @@
 
 use addresses::witness_program::WitnessProgram;
 use crypto::key::PubkeyHash;
+use network::Network;
 use primitives::script::{ScriptHash, ScriptPubKey};
 
 use crate::network::Params;
@@ -55,10 +56,27 @@ pub use self::error::{
 };
 #[doc(inline)]
 pub use addresses::{
-    Address, AddressData, AddressType, KnownHrp, NetworkUnchecked, NetworkValidation,
-    NetworkValidationUnchecked,
+    Address, AddressData, AddressParams, AddressType, KnownHrp, NetworkUnchecked,
+    NetworkValidation, NetworkValidationUnchecked,
 };
 
+impl From<&Params> for AddressParams {
+    fn from(params: &Params) -> Self {
+        match params.network {
+            Network::Bitcoin => Self::MAINNET,
+            Network::Regtest => Self::REGTEST,
+            Network::Signet => Self::SIGNET,
+            Network::Testnet(network::TestnetVersion::V4) => Self::TESTNET4,
+            Network::Testnet(network::TestnetVersion::V3) => Self::TESTNET3,
+            Network::Testnet(_) => Self::TESTNET3,
+        }
+    }
+}
+
+impl From<Params> for AddressParams {
+    fn from(params: Params) -> Self { Self::from(&params) }
+}
+
 mod sealed {
     pub trait Sealed {}
     impl Sealed for super::Address {}
@@ -70,21 +88,21 @@ crate::internal_macros::define_extension_trait! {
         /// Constructs a new [`Address`] from an output script (`scriptPubkey`).
         fn from_script(
             script: &ScriptPubKey,
-            params: impl AsRef<Params>,
+            params: impl Into<AddressParams>,
         ) -> Result<Address, FromScriptError> {
-            let network = params.as_ref().network;
+            let params = params.into();
             if script.is_p2pkh() {
                 let bytes = script.as_bytes()[3..23].try_into().expect("statically 20B long");
                 let hash = PubkeyHash::from_byte_array(bytes);
-                Ok(Self::p2pkh(hash, network))
+                Ok(Self::p2pkh(hash, params))
             } else if script.is_p2sh() {
                 let bytes = script.as_bytes()[2..22].try_into().expect("statically 20B long");
                 let hash = ScriptHash::from_byte_array(bytes);
-                Ok(Self::p2sh_from_hash(hash, network))
+                Ok(Self::p2sh_from_hash(hash, params))
             } else if let Some(version) = script.witness_version() {
                 let program = WitnessProgram::new(version, &script.as_bytes()[2..])
                     .map_err(FromScriptError::WitnessProgram)?;
-                Ok(Self::from_witness_program(program, network))
+                Ok(Self::from_witness_program(program, params))
             } else {
                 Err(FromScriptError::UnrecognizedScript)
             }
@@ -111,21 +129,20 @@ mod tests {
     use hex::hex;
 
     use super::*;
-    use crate::network::Network::{Bitcoin, Testnet};
-    use crate::network::{params, NetworkKind, TestnetVersion};
+    use crate::network::params;
     use crate::script::{RedeemScriptBuf, ScriptPubKeyBuf, WitnessScriptBuf};
     use crate::witness_version::WitnessVersion;
-    use crate::{FullPublicKey, LegacyPublicKey, Network, XOnlyPublicKey};
+    use crate::{FullPublicKey, LegacyPublicKey, XOnlyPublicKey};
 
-    fn roundtrips(addr: &Address, network: Network) {
+    fn roundtrips(addr: &Address, params: AddressParams) {
         assert_eq!(
             addr.to_string().parse::<Address<_>>().unwrap().assume_checked(),
             *addr,
             "string round-trip failed for {}",
             addr,
         );
         assert_eq!(
-            Address::from_script(&addr.script_pubkey(), network)
+            Address::from_script(&addr.script_pubkey(), params)
                 .expect("failed to create inner address from script_pubkey"),
             *addr,
             "script round-trip failed for {}",
@@ -144,7 +161,7 @@ mod tests {
     #[test]
     fn p2pkh_address_58() {
         let hash = "162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse::<PubkeyHash>().unwrap();
-        let addr = Address::p2pkh(hash, NetworkKind::Main);
+        let addr = Address::p2pkh(hash, AddressParams::MAINNET);
 
         assert_eq!(
             addr.script_pubkey(),
@@ -155,28 +172,28 @@ mod tests {
         );
         assert_eq!(&addr.to_string(), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM");
         assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
-        roundtrips(&addr, Bitcoin);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
     fn p2pkh_from_key() {
         let key = "048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183".parse::<LegacyPublicKey>().unwrap();
-        let addr = Address::p2pkh(key, NetworkKind::Main);
+        let addr = Address::p2pkh(key, AddressParams::MAINNET);
         assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY");
 
         let key = "03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f"
             .parse::<LegacyPublicKey>()
             .unwrap();
-        let addr = Address::p2pkh(key, NetworkKind::Test);
+        let addr = Address::p2pkh(key, AddressParams::TESTNET3);
         assert_eq!(&addr.to_string(), "mqkhEMH6NCeYjFybv7pvFC22MFeaNT9AQC");
         assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
-        roundtrips(&addr, Testnet(TestnetVersion::V3));
+        roundtrips(&addr, AddressParams::TESTNET3);
     }
 
     #[test]
     fn p2sh_address_58() {
         let hash = "162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse::<ScriptHash>().unwrap();
-        let addr = Address::p2sh_from_hash(hash, NetworkKind::Main);
+        let addr = Address::p2sh_from_hash(hash, AddressParams::MAINNET);
 
         assert_eq!(
             addr.script_pubkey(),
@@ -187,16 +204,16 @@ mod tests {
         );
         assert_eq!(&addr.to_string(), "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr, Bitcoin);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
     fn p2sh_parse() {
         let script = RedeemScriptBuf::from_hex_no_length_prefix("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae").unwrap();
-        let addr = Address::p2sh(&script, NetworkKind::Test).unwrap();
+        let addr = Address::p2sh(&script, AddressParams::TESTNET3).unwrap();
         assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr, Testnet(TestnetVersion::V3));
+        roundtrips(&addr, AddressParams::TESTNET3);
     }
 
     #[test]
@@ -205,23 +222,23 @@ mod tests {
         let key = "033bc8c83c52df5712229a2f72206d90192366c36428cb0c12b6af98324d97bfbc"
             .parse::<FullPublicKey>()
             .unwrap();
-        let addr = Address::p2wpkh(key, KnownHrp::Mainnet);
+        let addr = Address::p2wpkh(key, AddressParams::MAINNET);
         assert_eq!(&addr.to_string(), "bc1qvzvkjn4q3nszqxrv3nraga2r822xjty3ykvkuw");
         assert_eq!(addr.address_type(), Some(AddressType::P2wpkh));
-        roundtrips(&addr, Bitcoin);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
     fn p2wsh() {
         // stolen from Bitcoin transaction 5df912fda4becb1c29e928bec8d64d93e9ba8efa9b5b405bd683c86fd2c65667
         let script = WitnessScriptBuf::from_hex_no_length_prefix("52210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae").unwrap();
-        let addr = Address::p2wsh(&script, KnownHrp::Mainnet).expect("script is valid");
+        let addr = Address::p2wsh(&script, AddressParams::MAINNET).expect("script is valid");
         assert_eq!(
             &addr.to_string(),
             "bc1qwqdg6squsna38e46795at95yu9atm8azzmyvckulcc7kytlcckxswvvzej"
         );
         assert_eq!(addr.address_type(), Some(AddressType::P2wsh));
-        roundtrips(&addr, Bitcoin);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
@@ -230,20 +247,20 @@ mod tests {
         let key = "026c468be64d22761c30cd2f12cbc7de255d592d7904b1bab07236897cc4c2e766"
             .parse::<FullPublicKey>()
             .unwrap();
-        let addr = Address::p2shwpkh(key, NetworkKind::Main);
+        let addr = Address::p2shwpkh(key, AddressParams::MAINNET);
         assert_eq!(&addr.to_string(), "3QBRmWNqqBGme9er7fMkGqtZtp4gjMFxhE");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr, Bitcoin);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
     fn p2shwsh() {
         // stolen from Bitcoin transaction f9ee2be4df05041d0e0a35d7caa3157495ca4f93b233234c9967b6901dacf7a9
         let script = WitnessScriptBuf::from_hex_no_length_prefix("522103e5529d8eaa3d559903adb2e881eb06c86ac2574ffa503c45f4e942e2a693b33e2102e5f10fcdcdbab211e0af6a481f5532536ec61a5fdbf7183770cf8680fe729d8152ae").unwrap();
-        let addr = Address::p2shwsh(&script, NetworkKind::Main).expect("script is valid");
+        let addr = Address::p2shwsh(&script, AddressParams::MAINNET).expect("script is valid");
         assert_eq!(&addr.to_string(), "36EqgNnsWW94SreZgBWc1ANC6wpFZwirHr");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr, Bitcoin);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
@@ -254,8 +271,8 @@ mod tests {
         );
         let program = WitnessProgram::new(WitnessVersion::V13, &program).expect("valid program");
 
-        let addr = Address::from_witness_program(program, KnownHrp::Mainnet);
-        roundtrips(&addr, Bitcoin);
+        let addr = Address::from_witness_program(program, AddressParams::MAINNET);
+        roundtrips(&addr, AddressParams::MAINNET);
     }
 
     #[test]
@@ -356,13 +373,13 @@ mod tests {
         let internal_key = "cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115"
             .parse::<XOnlyPublicKey>()
             .unwrap();
-        let address = Address::p2tr(internal_key, None, KnownHrp::Mainnet);
+        let address = Address::p2tr(internal_key, None, AddressParams::MAINNET);
         assert_eq!(
             address.to_string(),
             "bc1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqkedrcr"
         );
         assert_eq!(address.address_type(), Some(AddressType::P2tr));
-        roundtrips(&address, Bitcoin);
+        roundtrips(&address, AddressParams::MAINNET);
     }
 
     #[test]
@@ -382,8 +399,8 @@ mod tests {
                 .unwrap();
         let expected = Err(FromScriptError::UnrecognizedScript);
 
-        assert_eq!(Address::from_script(&bad_p2wpkh, Network::Bitcoin), expected);
-        assert_eq!(Address::from_script(&bad_p2wsh, Network::Bitcoin), expected);
+        assert_eq!(Address::from_script(&bad_p2wpkh, AddressParams::MAINNET), expected);
+        assert_eq!(Address::from_script(&bad_p2wsh, AddressParams::MAINNET), expected);
         assert_eq!(
             Address::from_script(&invalid_segwitv0_script, &params::MAINNET),
             Err(FromScriptError::WitnessProgram(witness_program::Error::InvalidSegwitV0Length(17)))
@@ -403,13 +420,16 @@ mod tests {
             "bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e",
         ];
         for addr in &addresses {
-            let addr =
-                addr.parse::<Address<_>>().unwrap().require_network(Network::Bitcoin).unwrap();
+            let addr = addr
+                .parse::<Address<_>>()
+                .unwrap()
+                .require_network(AddressParams::MAINNET)
+                .unwrap();
             for another in &addresses {
                 let another = another
                     .parse::<Address<_>>()
                     .unwrap()
-                    .require_network(Network::Bitcoin)
+                    .require_network(AddressParams::MAINNET)
                     .unwrap();
                 assert_eq!(addr.matches_script_pubkey(&another.script_pubkey()), addr == another);
             }
@@ -424,7 +444,7 @@ mod tests {
 
         let script = ScriptPubKeyBuf::new_p2a();
         let address_unchecked = address_str.parse().unwrap();
-        let address = Address::from_script(&script, Network::Regtest).unwrap();
+        let address = Address::from_script(&script, AddressParams::REGTEST).unwrap();
         assert_eq!(address.as_unchecked(), &address_unchecked);
         assert_eq!(address.to_string(), address_str);
 

### bitcoin/src/crypto/key.rs
@@ -77,7 +77,7 @@ mod tests {
     use alloc::string::ToString;
 
     use super::*;
-    use crate::address::Address;
+    use crate::address::{Address, AddressParams};
     use crate::network::NetworkKind;
 
     #[test]
@@ -92,7 +92,7 @@ mod tests {
         assert!(sk.private_key.compressed());
         assert_eq!(&sk.to_wif(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
 
-        let pk = Address::p2pkh(sk.private_key.to_public_key(), sk.network_kind);
+        let pk = Address::p2pkh(sk.private_key.to_public_key(), AddressParams::TESTNET3);
         assert_eq!(&pk.to_string(), "mqwpxxvfv3QbM8PU8uBx2jaNt9btQqvQNx");
 
         // test string conversion
@@ -112,7 +112,7 @@ mod tests {
         assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
         assert_eq!(pk, "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"
         .parse::<LegacyPublicKey>().unwrap());
-        let addr = Address::p2pkh(pk, sk.network_kind);
+        let addr = Address::p2pkh(pk, AddressParams::MAINNET);
         assert_eq!(&addr.to_string(), "1GhQvF6dL8xa6wBxLnWmHcQsurx9RxiMc8");
         pk = pk.with_compressedness(true);
         assert_eq!(

### bitcoin/src/lib.rs
@@ -182,7 +182,7 @@ pub use key_expression::bip32;
 
 #[doc(inline)]
 pub use crate::{
-    address::{Address, AddressType, KnownHrp},
+    address::{Address, AddressParams, AddressType, KnownHrp},
     bip32::XKeyIdentifier,
     crypto::ecdsa,
     crypto::key::{

### bitcoin/src/sign_message.rs
@@ -263,7 +263,7 @@ mod tests {
     #[cfg(feature = "secp-recovery")]
     #[cfg(feature = "std")]
     fn message_signature() {
-        use crate::{Address, AddressType, FullPublicKey, Network, NetworkKind, PrivateKey};
+        use crate::{Address, AddressParams, AddressType, FullPublicKey, PrivateKey};
 
         let message = "rust-bitcoin MessageSignature test";
         let msg_hash = super::signed_msg_hash(message);
@@ -285,19 +285,19 @@ mod tests {
             .try_into()
             .expect("compressed was set to true");
 
-        let p2pkh = Address::p2pkh(pubkey, NetworkKind::Main);
+        let p2pkh = Address::p2pkh(pubkey, AddressParams::MAINNET);
         assert_eq!(signature2.is_signed_by_address(&p2pkh, msg_hash), Ok(true));
-        let p2wpkh = Address::p2wpkh(pubkey, Network::Bitcoin);
+        let p2wpkh = Address::p2wpkh(pubkey, AddressParams::MAINNET);
         assert_eq!(
             signature2.is_signed_by_address(&p2wpkh, msg_hash),
             Err(super::MessageSignatureError::UnsupportedAddressType(AddressType::P2wpkh))
         );
-        let p2shwpkh = Address::p2shwpkh(pubkey, NetworkKind::Main);
+        let p2shwpkh = Address::p2shwpkh(pubkey, AddressParams::MAINNET);
         assert_eq!(
             signature2.is_signed_by_address(&p2shwpkh, msg_hash),
             Err(super::MessageSignatureError::UnsupportedAddressType(AddressType::P2sh))
         );
-        let p2pkh = Address::p2pkh(pubkey, Network::Bitcoin);
+        let p2pkh = Address::p2pkh(pubkey, AddressParams::MAINNET);
         assert_eq!(signature2.is_signed_by_address(&p2pkh, msg_hash), Ok(true));
 
         assert_eq!(pubkey, FullPublicKey::from_private_key(&privkey));
@@ -314,7 +314,7 @@ mod tests {
         use base64::prelude::{Engine as _, BASE64_STANDARD};
 
         use crate::crypto::key::LegacyPublicKey;
-        use crate::{Address, NetworkKind};
+        use crate::{Address, AddressParams};
 
         let message = "a different message from what was signed";
         let msg_hash = super::signed_msg_hash(message);
@@ -331,7 +331,7 @@ mod tests {
         )
         .expect("pubkey slice");
 
-        let p2pkh = Address::p2pkh(pubkey, NetworkKind::Main);
+        let p2pkh = Address::p2pkh(pubkey, AddressParams::MAINNET);
         assert_eq!(signature.is_signed_by_address(&p2pkh, msg_hash), Ok(false));
     }
 

### bitcoin/tests/serde.rs
@@ -26,8 +26,8 @@ use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
 use bitcoin::taproot::{self, ControlBlock, LeafVersion, TapTree, TaprootBuilder};
 use bitcoin::witness::Witness;
 use bitcoin::{
-    ecdsa, hex, Address, LegacyPublicKey, NetworkKind, OutPoint, ScriptSigBuf, TapScriptBuf, Txid,
-    WifKey,
+    ecdsa, hex, Address, AddressParams, LegacyPublicKey, OutPoint, ScriptSigBuf, TapScriptBuf,
+    Txid, WifKey,
 };
 
 #[test]
@@ -110,7 +110,7 @@ fn serde_regression_witness() {
 fn serde_regression_address() {
     let s = include_str!("data/serde/public_key_hex");
     let pk = s.trim().parse::<LegacyPublicKey>().unwrap();
-    let addr = Address::p2pkh(pk, NetworkKind::Main);
+    let addr = Address::p2pkh(pk, AddressParams::MAINNET);
 
     let got = serialize(&addr).unwrap();
     let want = include_bytes!("data/serde/address_bincode") as &[_];

### bitcoin/tests/taproot.rs
@@ -5,7 +5,7 @@ use bitcoin::key::TapTweak as _;
 use bitcoin::taproot::{
     ControlBlock, LeafVersion, TapLeafHash, TapNodeHash, TapTweakHash, TaprootBuilder,
 };
-use bitcoin::{Address, KnownHrp, ScriptPubKeyBuf, TapScriptBuf, XOnlyPublicKey};
+use bitcoin::{Address, AddressParams, ScriptPubKeyBuf, TapScriptBuf, XOnlyPublicKey};
 
 #[test]
 fn bip_341_tests() {
@@ -85,7 +85,7 @@ fn bip_341_tests() {
 
         let tweak = TapTweakHash::from_key_and_merkle_root(internal_key, merkle_root);
         let output_key = internal_key.tap_tweak(merkle_root);
-        let addr = Address::p2tr(internal_key, merkle_root, KnownHrp::Mainnet);
+        let addr = Address::p2tr(internal_key, merkle_root, AddressParams::MAINNET);
         let spk = addr.script_pubkey();
 
         // Compare just the key bytes, not the parity

### fuzz/fuzz_targets/bitcoin/arbitrary_script.rs
@@ -2,7 +2,7 @@
 #![cfg_attr(not(fuzzing), allow(unused))]
 
 use arbitrary::{Arbitrary, Unstructured};
-use bitcoin::address::{Address, AddressExt as _};
+use bitcoin::address::{Address, AddressExt as _, AddressParams};
 use bitcoin::encoding::encode_to_vec;
 use bitcoin::script::{self, ScriptBuf, ScriptExt as _, ScriptPubKeyExt as _};
 use bitcoin::Network;
@@ -48,7 +48,7 @@ fn do_test(data: &[u8]) {
         assert_eq!(serialized, &encode_to_vec(script_buf.as_script())[..]);
 
         // Check if valid address and if that address roundtrips.
-        if let Ok(addr) = Address::from_script(&script_buf, Network::Bitcoin) {
+        if let Ok(addr) = Address::from_script(&script_buf, AddressParams::MAINNET) {
             assert_eq!(addr.script_pubkey(), script_buf);
         }
     }