more work

Author: QuantumExplorer

Cargo.lock

@@ -85,8 +85,8 @@ prometheus = "0.14"
 once_cell = "1.19"
 
 # Dash Core RPC client
-dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "e44b1fb2086ad57c8884995f9f93f14de91bf964" }
-dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "e44b1fb2086ad57c8884995f9f93f14de91bf964" }
+dashcore-rpc = { path = "../../../rust-dashcore/rpc-client" }
+dash-spv = { path = "../../../rust-dashcore/dash-spv" }
 
 rs-dash-event-bus = { path = "../rs-dash-event-bus" }
 

packages/rs-dapi/Cargo.toml

@@ -9,7 +9,7 @@ description = "Platform wallet with identity management support"
 [dependencies]
 # Dash Platform packages
 dpp = { path = "../rs-dpp" }
-dash-sdk = { path = "../rs-sdk", optional = true }
+dash-sdk = { path = "../rs-sdk", default-features = false, features = ["dashpay-contract", "dpns-contract"] }
 platform-encryption = { path = "../rs-platform-encryption" }
 
 # Key wallet dependencies (from rust-dashcore)
@@ -22,6 +22,7 @@ dashcore = { path = "../../../rust-dashcore/dash" }
 # Standard dependencies
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
+async-trait = "0.1"
 
 # Collections
 indexmap = "2.0"
@@ -31,8 +32,7 @@ rand = "0.8"
 
 
 [features]
-default = ["bls", "eddsa", "manager", "sdk"]
+default = ["bls", "eddsa", "manager"]
 bls = ["key-wallet/bls"]
 eddsa = ["key-wallet/eddsa"]
 manager = ["key-wallet-manager"]
-sdk = ["dep:dash-sdk"]

packages/rs-platform-wallet/Cargo.toml

@@ -3,7 +3,7 @@
 //! This module provides the `EstablishedContact` struct representing a bidirectional
 //! relationship (friendship) between two identities where both have sent contact requests.
 
-use crate::ContactRequest;
+#[allow(unused_imports)] use crate::ContactRequest;
 use dpp::prelude::Identifier;
 
 /// An established contact represents a bidirectional relationship between two identities

packages/rs-platform-wallet/src/established_contact.rs

@@ -14,7 +14,6 @@ impl IdentityManager {
     }
 
     /// Create a new identity manager with an SDK instance
-    #[cfg(feature = "sdk")]
     pub fn new_with_sdk(sdk: std::sync::Arc<dash_sdk::Sdk>) -> Self {
         Self {
             identities: indexmap::IndexMap::new(),
@@ -24,13 +23,11 @@ impl IdentityManager {
     }
 
     /// Set the SDK instance
-    #[cfg(feature = "sdk")]
     pub fn set_sdk(&mut self, sdk: std::sync::Arc<dash_sdk::Sdk>) {
         self.sdk = Some(sdk);
     }
 
     /// Get a reference to the SDK instance
-    #[cfg(feature = "sdk")]
     pub fn sdk(&self) -> Option<&std::sync::Arc<dash_sdk::Sdk>> {
         self.sdk.as_ref()
     }

packages/rs-platform-wallet/src/identity_manager/initializers.rs

@@ -7,7 +7,6 @@ use crate::managed_identity::ManagedIdentity;
 use dpp::prelude::Identifier;
 use indexmap::IndexMap;
 
-#[cfg(feature = "sdk")]
 use std::sync::Arc;
 
 // Import implementation modules
@@ -24,7 +23,6 @@ pub struct IdentityManager {
     pub primary_identity_id: Option<Identifier>,
 
     /// SDK instance for platform operations (optional, available with 'sdk' feature)
-    #[cfg(feature = "sdk")]
     pub sdk: Option<Arc<dash_sdk::Sdk>>,
 }
 
@@ -33,7 +31,6 @@ impl Default for IdentityManager {
         Self {
             identities: IndexMap::new(),
             primary_identity_id: None,
-            #[cfg(feature = "sdk")]
             sdk: None,
         }
     }

packages/rs-platform-wallet/src/identity_manager/mod.rs

@@ -19,11 +19,8 @@ use key_wallet::wallet::managed_wallet_info::ManagedAccountOperations;
 use key_wallet::Network;
 use key_wallet::Wallet;
 
-#[cfg(feature = "sdk")]
 use dpp::document::DocumentV0Getters;
-#[cfg(feature = "sdk")]
 use dpp::identity::signer::Signer;
-#[cfg(feature = "sdk")]
 use dpp::identity::IdentityPublicKey;
 
 impl PlatformWalletInfo {
@@ -323,7 +320,6 @@ impl PlatformWalletInfo {
     /// # Returns
     ///
     /// Returns the document ID and recipient ID on success
-    #[cfg(feature = "sdk")]
     pub async fn send_contact_request<S, F, Fut, G, Gut>(
         &mut self,
         wallet: &mut Wallet,

packages/rs-platform-wallet/src/platform_wallet_info/contact_requests.rs

@@ -1,7 +1,7 @@
-//! Processing matured transactions for identity registration detection
+//! Processing asset lock transactions for identity registration detection
 //!
 //! This module handles the detection and fetching of identities created from
-//! matured asset lock transactions.
+//! asset lock transactions.
 
 use super::PlatformWalletInfo;
 use crate::error::PlatformWalletError;
@@ -10,34 +10,79 @@ use dpp::prelude::Identifier;
 use key_wallet::wallet::immature_transaction::ImmatureTransaction;
 use key_wallet::Network;
 
-#[cfg(feature = "sdk")]
-use crate::ContactRequest;
+#[allow(unused_imports)] use crate::ContactRequest;
 
-#[cfg(feature = "sdk")]
 use dpp::identity::accessors::IdentityGettersV0;
 
 impl PlatformWalletInfo {
-    /// Discover identities and fetch contact requests after matured asset locks
+    /// Discover identity and fetch contact requests for a single asset lock transaction
     ///
-    /// When asset lock transactions mature, identities may have been registered.
+    /// This is called automatically when an asset lock transaction is detected.
+    ///
+    /// # Arguments
+    ///
+    /// * `wallet` - The wallet to derive authentication keys from
+    /// * `network` - The network to operate on
+    /// * `tx` - The asset lock transaction
+    ///
+    /// # Returns
+    ///
+    /// Returns Ok(Some(identity_id)) if found, Ok(None) if not found
+    pub async fn fetch_identity_and_contacts_for_asset_lock(
+        &mut self,
+        wallet: &key_wallet::Wallet,
+        network: Network,
+        tx: &dashcore::Transaction,
+    ) -> Result<Option<Identifier>, PlatformWalletError> {
+        use dashcore::hashes::Hash;
+        use key_wallet::wallet::immature_transaction::AffectedAccounts;
+
+        // Create an ImmatureTransaction wrapper
+        // Note: For asset locks detected in check_transaction, we don't have full block info yet
+        // We use placeholder values for height/block_hash since we only need the transaction
+        // for identity discovery
+        let immature_tx = ImmatureTransaction {
+            transaction: tx.clone(),
+            txid: tx.txid(),
+            height: 0, // Placeholder - not used for identity discovery
+            block_hash: dashcore::BlockHash::all_zeros(),
+            timestamp: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs(),
+            maturity_confirmations: 0,
+            affected_accounts: AffectedAccounts::new(),
+            total_received: 0,
+            is_coinbase: false,
+        };
+
+        let result = self
+            .fetch_contact_requests_for_identities_after_asset_locks(wallet, network, &[immature_tx])
+            .await?;
+
+        Ok(result.first().copied())
+    }
+
+    /// Discover identities and fetch contact requests after asset locks
+    ///
+    /// When asset lock transactions are seen (added as immature), identities may have been registered.
     /// This searches for the first identity key to discover newly registered identities
     /// and fetches their DashPay contact requests.
     ///
     /// # Arguments
     ///
     /// * `wallet` - The wallet to derive authentication keys from
     /// * `network` - The network to operate on
-    /// * `matured_transactions` - List of matured transactions from process_matured_transactions
+    /// * `asset_lock_transactions` - List of asset lock transactions from pending_asset_locks
     ///
     /// # Returns
     ///
     /// Returns a list of identity IDs for which contact requests were fetched
-    #[cfg(feature = "sdk")]
-    pub async fn fetch_contact_requests_for_identities_after_matured_asset_locks(
+    pub async fn fetch_contact_requests_for_identities_after_asset_locks(
         &mut self,
         wallet: &key_wallet::Wallet,
         network: Network,
-        matured_transactions: &[ImmatureTransaction],
+        asset_lock_transactions: &[ImmatureTransaction],
     ) -> Result<Vec<Identifier>, PlatformWalletError> {
         use dash_sdk::platform::types::identity::PublicKeyHash;
         use dash_sdk::platform::Fetch;
@@ -46,14 +91,7 @@ impl PlatformWalletInfo {
         let mut identities_processed = Vec::new();
 
         // Early return if no asset lock transactions
-        let has_asset_locks = matured_transactions.iter().any(|tx| {
-            matches!(
-                &tx.transaction.special_transaction_payload,
-                Some(TransactionPayload::AssetLockPayloadType(_))
-            )
-        });
-
-        if !has_asset_locks {
+        if asset_lock_transactions.is_empty() {
             return Ok(identities_processed);
         }
 
@@ -197,7 +235,6 @@ impl PlatformWalletInfo {
 }
 
 /// Parse a contact request document into a ContactRequest struct
-#[cfg(feature = "sdk")]
 fn parse_contact_request_document(
     doc: &dpp::document::Document,
 ) -> Result<ContactRequest, PlatformWalletError> {
@@ -283,16 +320,4 @@ fn parse_contact_request_document(
         created_at_core_block_height,
         created_at,
     ))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_contact_request_document_basic() {
-        // This is a basic compilation test
-        // Full testing would require creating mock Document instances
-        assert!(true);
-    }
-}
+}

packages/rs-platform-wallet/src/platform_wallet_info/matured_transactions.rs

@@ -110,38 +110,12 @@ impl WalletInfoInterface for PlatformWalletInfo {
         network: Network,
         current_height: u32,
     ) -> Vec<ImmatureTransaction> {
-        let matured = self
-            .wallet_info
-            .process_matured_transactions(network, current_height);
-
-        // Process each matured transaction to check for identity registrations
-        #[cfg(feature = "sdk")]
-        {
-            use dashcore::transaction::special_transaction::TransactionPayload;
-
-            for immature_tx in &matured {
-                // Check if this is an asset lock transaction (identity registration)
-                if let Some(TransactionPayload::AssetLockPayloadType(_asset_lock)) =
-                    &immature_tx.transaction.special_transaction_payload
-                {
-                    // This is an asset lock transaction - we need to find the identity
-                    // The identity would have been registered using credits from this asset lock
-                    // We'll need to query the platform for identities created from this transaction
-
-                    // Note: This is a synchronous context, so we can't make async SDK calls here
-                    // The actual fetching will need to be done by the caller after this returns
-                    // by calling a separate method to fetch identities for matured asset locks
-
-                    // For now, we just detect it and log (or mark it for processing)
-                    // The caller should call fetch_identities_for_asset_lock() after this
-                }
-            }
-        }
-
-        matured
+        self.wallet_info
+            .process_matured_transactions(network, current_height)
     }
 
     fn add_immature_transaction(&mut self, network: Network, tx: ImmatureTransaction) {
+        // Delegate to the underlying wallet_info
         self.wallet_info.add_immature_transaction(network, tx)
     }
 
@@ -173,4 +147,9 @@ impl WalletInfoInterface for PlatformWalletInfo {
             current_block_height,
         )
     }
+
+    fn update_chain_height(&mut self, network: Network, current_height: u32) {
+        // Delegate to the underlying wallet_info
+        self.wallet_info.update_chain_height(network, current_height)
+    }
 }

packages/rs-platform-wallet/src/platform_wallet_info/wallet_info_interface.rs

@@ -1,21 +1,51 @@
 use crate::platform_wallet_info::PlatformWalletInfo;
+use async_trait::async_trait;
 use dashcore::{Network, Transaction};
 use key_wallet::transaction_checking::{
     TransactionCheckResult, TransactionContext, WalletTransactionChecker,
 };
 use key_wallet::Wallet;
 
-/// Implement WalletTransactionChecker by delegating to ManagedWalletInfo
+/// Implement WalletTransactionChecker for PlatformWalletInfo
+#[async_trait]
 impl WalletTransactionChecker for PlatformWalletInfo {
-    fn check_transaction(
+    async fn check_transaction(
         &mut self,
         tx: &Transaction,
         network: Network,
         context: TransactionContext,
-        update_state_with_wallet_if_found: Option<&Wallet>,
+        wallet: &mut Wallet,
+        update_state: bool,
     ) -> TransactionCheckResult {
-        // Delegate to the underlying wallet info
-        self.wallet_info
-            .check_transaction(tx, network, context, update_state_with_wallet_if_found)
+        // Check transaction with underlying wallet info
+        let result = self
+            .wallet_info
+            .check_transaction(tx, network, context, wallet, update_state)
+            .await;
+
+        // If the transaction is relevant, and it's an asset lock, automatically fetch identities
+        if result.is_relevant {
+            use dashcore::transaction::special_transaction::TransactionPayload;
+
+            if matches!(
+                &tx.special_transaction_payload,
+                Some(TransactionPayload::AssetLockPayloadType(_))
+            ) {
+                // Check if we have an SDK configured for this network
+                if let Some(identity_manager) = self.identity_managers.get(&network) {
+                    if identity_manager.sdk.is_some() {
+                        // Call the identity fetching logic
+                        if let Err(e) = self
+                            .fetch_identity_and_contacts_for_asset_lock(wallet, network, tx)
+                            .await
+                        {
+                            eprintln!("Failed to fetch identity for asset lock: {}", e);
+                        }
+                    }
+                }
+            }
+        }
+
+        result
     }
 }