feat: bump rust-dashcore to mempool support (1af96dd)

Update all 6 rust-dashcore workspace dependencies to commit
1af96dd02f12576ba0727476e39ff78aca0a1e13 which adds MempoolManager
(8th parallel sync manager) with bloom filter based mempool monitoring.

Remove "std" feature from rs-dpp dashcore dependency as it was
eliminated upstream.

Adapt to upstream API changes:
- Network::Dash renamed to Network::Mainnet
- DMNState.service changed from SocketAddr to Option<SocketAddr>
- WalletInfoInterface gained mark_instant_send_utxos method
- WalletTransactionChecker::check_core_transaction gained update_balance param

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lklimek

Cargo.lock

@@ -47,12 +47,12 @@ members = [
 ]
 
 [workspace.dependencies]
-dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "9959201593826def0ad1f6db51b2ceb95b68a1ca" }
-dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "9959201593826def0ad1f6db51b2ceb95b68a1ca" }
-dash-spv-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "9959201593826def0ad1f6db51b2ceb95b68a1ca" }
-key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "9959201593826def0ad1f6db51b2ceb95b68a1ca" }
-key-wallet-manager = { git = "https://github.com/dashpay/rust-dashcore", rev = "9959201593826def0ad1f6db51b2ceb95b68a1ca" }
-dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "9959201593826def0ad1f6db51b2ceb95b68a1ca" }
+dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "1af96dd02f12576ba0727476e39ff78aca0a1e13" }
+dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "1af96dd02f12576ba0727476e39ff78aca0a1e13" }
+dash-spv-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "1af96dd02f12576ba0727476e39ff78aca0a1e13" }
+key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "1af96dd02f12576ba0727476e39ff78aca0a1e13" }
+key-wallet-manager = { git = "https://github.com/dashpay/rust-dashcore", rev = "1af96dd02f12576ba0727476e39ff78aca0a1e13" }
+dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "1af96dd02f12576ba0727476e39ff78aca0a1e13" }
 
 # Optimize heavy crypto crates even in dev/test builds so that
 # Halo 2 proof generation and verification run at near-release speed.

Cargo.toml

@@ -25,7 +25,6 @@ chrono = { version = "0.4.35", default-features = false, features = [
 chrono-tz = { version = "0.8", optional = true }
 ciborium = { version = "0.2.2", optional = true }
 dashcore = { workspace = true, features = [
-  "std",
   "secp-recovery",
   "rand",
   "signer",

packages/rs-dpp/Cargo.toml

@@ -96,7 +96,7 @@ impl OrchardAddress {
 
         let hrp_lower = hrp.as_str().to_ascii_lowercase();
         let network = match hrp_lower.as_str() {
-            s if s == PLATFORM_HRP_MAINNET => Network::Dash,
+            s if s == PLATFORM_HRP_MAINNET => Network::Mainnet,
             s if s == PLATFORM_HRP_TESTNET => Network::Testnet,
             _ => {
                 return Err(ProtocolError::DecodingError(format!(
@@ -182,7 +182,7 @@ mod tests {
     fn test_orchard_bech32m_mainnet_roundtrip() {
         let address = test_orchard_address();
 
-        let encoded = address.to_bech32m_string(Network::Dash);
+        let encoded = address.to_bech32m_string(Network::Mainnet);
         assert!(
             encoded.starts_with("dash1z"),
             "Orchard mainnet address should start with 'dash1z', got: {}",
@@ -192,7 +192,7 @@ mod tests {
         let (decoded, network) =
             OrchardAddress::from_bech32m_string(&encoded).expect("decoding should succeed");
         assert_eq!(decoded, address);
-        assert_eq!(network, Network::Dash);
+        assert_eq!(network, Network::Mainnet);
     }
 
     #[test]
@@ -250,9 +250,9 @@ mod tests {
         let p2sh = PlatformAddress::P2sh([0xAB; 20]);
         let orchard = test_orchard_address();
 
-        let p2pkh_enc = p2pkh.to_bech32m_string(Network::Dash);
-        let p2sh_enc = p2sh.to_bech32m_string(Network::Dash);
-        let orchard_enc = orchard.to_bech32m_string(Network::Dash);
+        let p2pkh_enc = p2pkh.to_bech32m_string(Network::Mainnet);
+        let p2sh_enc = p2sh.to_bech32m_string(Network::Mainnet);
+        let orchard_enc = orchard.to_bech32m_string(Network::Mainnet);
 
         // All three start with "dash1" but have different type-byte characters
         assert!(p2pkh_enc.starts_with("dash1k"), "P2PKH: {}", p2pkh_enc);

packages/rs-dpp/src/address_funds/orchard_address.rs

@@ -103,7 +103,7 @@ impl PlatformAddress {
     /// - Testnet/Devnet/Regtest: "tdash"
     pub fn hrp_for_network(network: Network) -> &'static str {
         match network {
-            Network::Dash => PLATFORM_HRP_MAINNET,
+            Network::Mainnet => PLATFORM_HRP_MAINNET,
             Network::Testnet | Network::Devnet | Network::Regtest => PLATFORM_HRP_TESTNET,
             // For any other networks, default to testnet HRP
             _ => PLATFORM_HRP_TESTNET,
@@ -123,7 +123,7 @@ impl PlatformAddress {
     /// # Example
     /// ```ignore
     /// let address = PlatformAddress::P2pkh([0xf7, 0xda, ...]);
-    /// let encoded = address.to_bech32m_string(Network::Dash);
+    /// let encoded = address.to_bech32m_string(Network::Mainnet);
     /// // Returns something like "dash1k..."
     /// ```
     pub fn to_bech32m_string(&self, network: Network) -> String {
@@ -164,7 +164,7 @@ impl PlatformAddress {
         // Determine network from HRP (case-insensitive per DIP-0018)
         let hrp_lower = hrp.as_str().to_ascii_lowercase();
         let network = match hrp_lower.as_str() {
-            s if s == PLATFORM_HRP_MAINNET => Network::Dash,
+            s if s == PLATFORM_HRP_MAINNET => Network::Mainnet,
             s if s == PLATFORM_HRP_TESTNET => Network::Testnet,
             _ => {
                 return Err(ProtocolError::DecodingError(format!(
@@ -1030,7 +1030,7 @@ mod tests {
         let address = PlatformAddress::P2pkh(hash);
 
         // Encode to bech32m
-        let encoded = address.to_bech32m_string(Network::Dash);
+        let encoded = address.to_bech32m_string(Network::Mainnet);
 
         // Verify exact encoding
         assert_eq!(
@@ -1042,7 +1042,7 @@ mod tests {
         let (decoded, network) =
             PlatformAddress::from_bech32m_string(&encoded).expect("decoding should succeed");
         assert_eq!(decoded, address);
-        assert_eq!(network, Network::Dash);
+        assert_eq!(network, Network::Mainnet);
     }
 
     #[test]
@@ -1080,7 +1080,7 @@ mod tests {
         let address = PlatformAddress::P2sh(hash);
 
         // Encode to bech32m
-        let encoded = address.to_bech32m_string(Network::Dash);
+        let encoded = address.to_bech32m_string(Network::Mainnet);
 
         // Verify exact encoding
         assert_eq!(
@@ -1092,7 +1092,7 @@ mod tests {
         let (decoded, network) =
             PlatformAddress::from_bech32m_string(&encoded).expect("decoding should succeed");
         assert_eq!(decoded, address);
-        assert_eq!(network, Network::Dash);
+        assert_eq!(network, Network::Mainnet);
     }
 
     #[test]
@@ -1170,7 +1170,7 @@ mod tests {
         // Create a valid address, then corrupt the checksum
         let hash: [u8; 20] = [0xAB; 20];
         let address = PlatformAddress::P2pkh(hash);
-        let mut encoded = address.to_bech32m_string(Network::Dash);
+        let mut encoded = address.to_bech32m_string(Network::Mainnet);
 
         // Corrupt the last character (part of checksum)
         let last_char = encoded.pop().unwrap();
@@ -1239,7 +1239,7 @@ mod tests {
         let hash: [u8; 20] = [0xAB; 20];
         let address = PlatformAddress::P2pkh(hash);
 
-        let lowercase = address.to_bech32m_string(Network::Dash);
+        let lowercase = address.to_bech32m_string(Network::Mainnet);
         let uppercase = lowercase.to_uppercase();
 
         // Both should decode to the same address
@@ -1254,7 +1254,7 @@ mod tests {
     fn test_bech32m_all_zeros_p2pkh() {
         // Edge case: all-zero hash
         let address = PlatformAddress::P2pkh([0u8; 20]);
-        let encoded = address.to_bech32m_string(Network::Dash);
+        let encoded = address.to_bech32m_string(Network::Mainnet);
         let (decoded, _) = PlatformAddress::from_bech32m_string(&encoded).unwrap();
         assert_eq!(decoded, address);
     }
@@ -1263,14 +1263,14 @@ mod tests {
     fn test_bech32m_all_ones_p2sh() {
         // Edge case: all-ones hash
         let address = PlatformAddress::P2sh([0xFF; 20]);
-        let encoded = address.to_bech32m_string(Network::Dash);
+        let encoded = address.to_bech32m_string(Network::Mainnet);
         let (decoded, _) = PlatformAddress::from_bech32m_string(&encoded).unwrap();
         assert_eq!(decoded, address);
     }
 
     #[test]
     fn test_hrp_for_network() {
-        assert_eq!(PlatformAddress::hrp_for_network(Network::Dash), "dash");
+        assert_eq!(PlatformAddress::hrp_for_network(Network::Mainnet), "dash");
         assert_eq!(PlatformAddress::hrp_for_network(Network::Testnet), "tdash");
         assert_eq!(PlatformAddress::hrp_for_network(Network::Devnet), "tdash");
         assert_eq!(PlatformAddress::hrp_for_network(Network::Regtest), "tdash");
@@ -1312,8 +1312,8 @@ mod tests {
         assert_eq!(p2sh.to_bytes()[0], 0x01);
 
         // Bech32m encoding uses 0xb0/0xb8 (verified by successful roundtrip)
-        let p2pkh_encoded = p2pkh.to_bech32m_string(Network::Dash);
-        let p2sh_encoded = p2sh.to_bech32m_string(Network::Dash);
+        let p2pkh_encoded = p2pkh.to_bech32m_string(Network::Mainnet);
+        let p2sh_encoded = p2sh.to_bech32m_string(Network::Mainnet);
 
         let (p2pkh_decoded, _) = PlatformAddress::from_bech32m_string(&p2pkh_encoded).unwrap();
         let (p2sh_decoded, _) = PlatformAddress::from_bech32m_string(&p2sh_encoded).unwrap();

packages/rs-dpp/src/address_funds/platform_address.rs

@@ -16,7 +16,7 @@ pub trait NetworkCoreSubsidy {
 impl NetworkCoreSubsidy for Network {
     fn core_subsidy_halving_interval(&self) -> u32 {
         match self {
-            Network::Dash => 210240,
+            Network::Mainnet => 210240,
             Network::Testnet => 210240,
             Network::Devnet => 210240,
             Network::Regtest => 150,

packages/rs-dpp/src/core_subsidy/mod.rs

@@ -18,7 +18,7 @@ impl RewardDistributionType {
         match self {
             RewardDistributionType::BlockBasedDistribution { interval, .. } => {
                 let min_block_interval = match network_type {
-                    Network::Dash => 100,
+                    Network::Mainnet => 100,
                     Network::Testnet => 5,
                     Network::Devnet => 2,
                     Network::Regtest => 1,
@@ -37,7 +37,7 @@ impl RewardDistributionType {
             }
             RewardDistributionType::TimeBasedDistribution { interval, .. } => {
                 let min_block_interval = match network_type {
-                    Network::Dash => 3_600_000,
+                    Network::Mainnet => 3_600_000,
                     Network::Testnet => 600_000,
                     Network::Devnet => 60_000,
                     Network::Regtest => 60_000,

packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_type/validation/v0/mod.rs

@@ -163,7 +163,7 @@ impl KeyType {
                 let secp = Secp256k1::new();
                 let mut rng = EcdsaRng::from_rng(rng).unwrap();
                 let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
-                let private_key = dashcore::PrivateKey::new(secret_key, Network::Dash);
+                let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
                 private_key.public_key(&secp).to_bytes()
             }
             KeyType::BLS12_381 => {
@@ -269,7 +269,7 @@ impl KeyType {
                 let secp = Secp256k1::new();
                 let mut rng = EcdsaRng::from_rng(rng).unwrap();
                 let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
-                let private_key = dashcore::PrivateKey::new(secret_key, Network::Dash);
+                let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
                 (
                     private_key.public_key(&secp).to_bytes(),
                     private_key.inner.secret_bytes(),
@@ -284,7 +284,7 @@ impl KeyType {
                 let secp = Secp256k1::new();
                 let mut rng = EcdsaRng::from_rng(rng).unwrap();
                 let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
-                let private_key = dashcore::PrivateKey::new(secret_key, Network::Dash);
+                let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
                 (
                     ripemd160_sha256(private_key.public_key(&secp).to_bytes().as_slice()).to_vec(),
                     private_key.inner.secret_bytes(),
@@ -302,7 +302,7 @@ impl KeyType {
                 let secp = Secp256k1::new();
                 let mut rng = EcdsaRng::from_rng(rng).unwrap();
                 let secret_key = dashcore::secp256k1::SecretKey::new(&mut rng);
-                let private_key = dashcore::PrivateKey::new(secret_key, Network::Dash);
+                let private_key = dashcore::PrivateKey::new(secret_key, Network::Mainnet);
                 (
                     ripemd160_sha256(private_key.public_key(&secp).to_bytes().as_slice()).to_vec(),
                     private_key.inner.secret_bytes(),

packages/rs-dpp/src/identity/identity_public_key/key_type.rs

@@ -77,7 +77,7 @@ where
     // For the mainnet chain, we enable these fixes at the block when we consider the state is consistent.
     let config = &app.platform().config;
 
-    if app.platform().config.network == Network::Dash
+    if app.platform().config.network == Network::Mainnet
         && config.abci.chain_id == "evo1"
         && block_height < 33000
     {

packages/rs-drive-abci/src/abci/handler/finalize_block.rs

@@ -50,7 +50,7 @@ where
     let config = &app.platform().config;
 
     #[allow(clippy::collapsible_if)]
-    if !(config.network == Network::Dash
+    if !(config.network == Network::Mainnet
         && config.abci.chain_id == "evo1"
         && last_block_height < 33000)
     {