dashpay · QuantumExplorer · Apr 2, 2026 · Mar 20, 2026 · Mar 20, 2026 · Mar 20, 2026
@@ -47,13 +47,13 @@ members = [
 ]
 
 [workspace.dependencies]
-dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
-dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
-dash-spv-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
-key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
-key-wallet-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
-key-wallet-manager = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
-dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "5db46b4d2bdc50b0fbc8d9acbebe72775bb4132a" }
+dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
+dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
+dash-spv-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
+key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
+key-wallet-ffi = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
+key-wallet-manager = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
+dashcore-rpc = { git = "https://github.com/dashpay/rust-dashcore", rev = "6638745c27119778d4c78959003955f00bad373c" }
 
 # Optimize heavy crypto crates even in dev/test builds so that
 # Halo 2 proof generation and verification run at near-release speed.

@@ -331,21 +331,47 @@ pub unsafe extern "C" fn dash_sdk_create_trusted(config: *const DashSDKConfig) -
     );
 
     // Create trusted context provider
-    let trusted_provider = match rs_sdk_trusted_context_provider::TrustedHttpContextProvider::new(
-        network,
-        None,                                      // Use default quorum lookup endpoints
-        std::num::NonZeroUsize::new(100).unwrap(), // Cache size
-    ) {
-        Ok(provider) => {
-            info!("dash_sdk_create_trusted: trusted context provider created");
-            Arc::new(provider)
+    // For local/regtest, use the quorum sidecar at localhost:22444 (dashmate Docker default)
+    let is_local = matches!(
+        config.network,
+        DashSDKNetwork::SDKLocal | DashSDKNetwork::SDKRegtest
+    );
+    let trusted_provider = if is_local {
+        info!("dash_sdk_create_trusted: using local quorum sidecar for regtest");
+        match rs_sdk_trusted_context_provider::TrustedHttpContextProvider::new_with_url(
+            network,
+            "http://127.0.0.1:22444".to_string(),
+            std::num::NonZeroUsize::new(100).unwrap(),
+        ) {
+            Ok(provider) => {
+                info!("dash_sdk_create_trusted: local trusted context provider created");
+                Arc::new(provider)
+            }
+            Err(e) => {
+                error!(error = %e, "dash_sdk_create_trusted: failed to create local context provider");
+                return DashSDKResult::error(DashSDKError::new(
+                    DashSDKErrorCode::InternalError,
+                    format!("Failed to create local context provider: {}", e),
+                ));
+            }
         }
-        Err(e) => {
-            error!(error = %e, "dash_sdk_create_trusted: failed to create trusted context provider");
-            return DashSDKResult::error(DashSDKError::new(
-                DashSDKErrorCode::InternalError,
-                format!("Failed to create trusted context provider: {}", e),
-            ));
+    } else {
+        match rs_sdk_trusted_context_provider::TrustedHttpContextProvider::new(
+            network,
+            None,                                      // Use default quorum lookup endpoints
+            std::num::NonZeroUsize::new(100).unwrap(), // Cache size
+        ) {
+            Ok(provider) => {
+                info!("dash_sdk_create_trusted: trusted context provider created");
+                Arc::new(provider)
+            }
+            Err(e) => {
+                error!(error = %e, "dash_sdk_create_trusted: failed to create trusted context provider");
+                return DashSDKResult::error(DashSDKError::new(
+                    DashSDKErrorCode::InternalError,
+                    format!("Failed to create trusted context provider: {}", e),
+                ));
+            }
         }
     };
 

@@ -21,6 +21,9 @@ public enum AccountCategory: Equatable, Hashable, Sendable {
     case providerOwnerKeys
     case providerOperatorKeys
     case providerPlatformKeys
+    case dashPayReceivingFunds
+    case dashPayExternalAccount
+    case platformPayment
 }
 
 // MARK: - Account Info

@@ -44,6 +44,9 @@ class SPVClient: @unchecked Sendable {
                 return dash_spv_ffi_config_mainnet()
             case 1:
                 return dash_spv_ffi_config_testnet()
+            case 2:
+                // Regtest (local Docker)
+                return dash_spv_ffi_config_new(FFINetwork(rawValue: 2))
             case 3:
                 // Map devnet to custom FFINetwork value 3
                 return dash_spv_ffi_config_new(FFINetwork(rawValue: 3))
@@ -58,13 +61,16 @@ class SPVClient: @unchecked Sendable {
 
         // If requested, prefer local core peers (defaults to 127.0.0.1 with network default port)
         let useLocalCore = UserDefaults.standard.bool(forKey: "useLocalhostCore")
+            || UserDefaults.standard.bool(forKey: "useDockerSetup")
         // Only restrict to configured peers when using local core, if not, allow DNS discovery
         let restrictToConfiguredPeers = useLocalCore
         if useLocalCore {
             let peers = SPVClient.readLocalCorePeers()
             if swiftLoggingEnabled {
                 print("[SPV][Config] Use Local Core enabled; peers=\(peers.joined(separator: ", "))")
             }
+            // Clear default peers before adding custom Docker peers
+            dash_spv_ffi_config_clear_peers(configPtr)
             // Add peers via FFI (supports "ip:port" or bare IP for network-default port)
             for addr in peers {
                 addr.withCString { cstr in
@@ -135,9 +141,9 @@ class SPVClient: @unchecked Sendable {
     }
 
     private static func readLocalCorePeers() -> [String] {
-        // If no override is set, default to 127.0.0.1 and let FFI pick port by network
+        // If no override is set, default to dashmate Docker Core P2P port
         let raw = UserDefaults.standard.string(forKey: "corePeerAddresses")?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let list = (raw?.isEmpty == false ? raw! : "127.0.0.1")
+        let list = (raw?.isEmpty == false ? raw! : "127.0.0.1:20001")
         return list
             .split(separator: ",")
             .map { $0.trimmingCharacters(in: .whitespaces) }
@@ -190,6 +196,25 @@ class SPVClient: @unchecked Sendable {
         config = nil
     }
 
+    // MARK: - Broadcast Transactions
+
+    func broadcastTransaction(_ transactionData: Data) throws {
+        try transactionData.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) in
+            guard let txBytes = ptr.bindMemory(to: UInt8.self).baseAddress else {
+                throw SPVError.transactionBroadcastFailed("Invalid transaction data pointer")
+            }
+            let result = dash_spv_ffi_client_broadcast_transaction(
+                client,
+                txBytes,
+                UInt(transactionData.count)
+            )
+
+            if result != 0 {
+                throw SPVError.transactionBroadcastFailed(SPVClient.getLastDashFFIError())
+            }
+        }
+    }
+
     // MARK: - Synchronization
 
     func startSync() async throws {
@@ -235,6 +260,7 @@ public enum SPVError: LocalizedError {
     case alreadySyncing
     case syncFailed(String)
     case storageOperationFailed(String)
+    case transactionBroadcastFailed(String)
 
     public var errorDescription: String? {
         switch self {
@@ -254,6 +280,8 @@ public enum SPVError: LocalizedError {
             return "Sync failed: \(reason)"
         case let .storageOperationFailed(reason):
             return reason
+        case let .transactionBroadcastFailed(reason):
+            return "Transaction broadcast failed: \(reason)"
         }
     }
 }
@@ -104,6 +104,9 @@ public class WalletService: ObservableObject {
     private var spvClient: SPVClient
     public private(set) var walletManager: CoreWalletManager
 
+    // InstantSend lock storage for asset lock flow
+    private let instantLockStore = InstantLockStore()
+
     public init(modelContainer: ModelContainer, network: AppNetwork) {
         self.modelContainer = modelContainer
         self.network = network
@@ -236,6 +239,19 @@ public class WalletService: ObservableObject {
       self.initializeNewSPVClient()
     }
 
+    // MARK: - Transaction Broadcasting
+
+    /// Broadcast a raw transaction on the Core P2P network.
+    public func broadcastTransaction(_ transactionData: Data) throws {
+        try spvClient.broadcastTransaction(transactionData)
+    }
+
+    /// Wait for an InstantSend lock for a specific transaction.
+    /// Returns the serialized IS lock bytes when received, or throws on timeout.
+    public func waitForInstantLock(txid: Data, timeout: TimeInterval = 30) async throws -> Data {
+        try await instantLockStore.waitForLock(txid: txid, timeout: timeout)
+    }
+
     public func clearSpvStorage() {
         if syncProgress.state.isRunning() {
             print("[SPV][Clear] Sync task is running, cannot clear storage")
@@ -314,7 +330,9 @@ public class WalletService: ObservableObject {
         func onBlocksProcessed(_ height: UInt32, _ hash: Data, _ newAddressCount: UInt32) {}
         func onMasternodeStateUpdated(_ height: UInt32) {}
         func onChainLockReceived(_ height: UInt32, _ hash:  Data, _ signature: Data, _ validated: Bool) {}
-        func onInstantLockReceived(_ txid: Data, _ instantLockData: Data, _ validated: Bool) {}
+        func onInstantLockReceived(_ txid: Data, _ instantLockData: Data, _ validated: Bool) {
+            walletService.instantLockStore.store(txid: txid, lockData: instantLockData)
+        }
         func onSyncManagerError(_ manager: SPVSyncManager, _ errorMsg: String) {
             SDKLogger.error("Sync manager \(manager) error: \(errorMsg)")
 
@@ -393,3 +411,45 @@ extension Data {
         return map { String(format: "%02hhx", $0) }.joined()
     }
 }
+
+// MARK: - InstantSend Lock Store
+
+/// Thread-safe store for InstantSend lock data, keyed by txid.
+/// Supports async waiting for a specific txid's IS lock to arrive.
+internal final class InstantLockStore: @unchecked Sendable {
+    private var locks: [Data: Data] = [:]
+    private var continuations: [Data: CheckedContinuation<Data, Error>] = [:]
+    private let queue = DispatchQueue(label: "com.dash.instantlock-store")
+
+    /// Store an IS lock. Resumes waiter if one exists for this txid.
+    func store(txid: Data, lockData: Data) {
+        var cont: CheckedContinuation<Data, Error>?
+        queue.sync {
+            locks[txid] = lockData
+            cont = continuations.removeValue(forKey: txid)
+        }
+        cont?.resume(returning: lockData)
+    }
+
+    /// Wait for an IS lock for a specific txid.
+    /// Returns immediately if already cached, otherwise polls until received or timeout.
+    func waitForLock(txid: Data, timeout: TimeInterval = 30) async throws -> Data {
+        // Check if already available
+        if let existing = queue.sync(execute: { locks[txid] }) {
+            return existing
+        }
+
+        // Poll-based approach — simpler and avoids continuation resume races
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            try await Task.sleep(nanoseconds: 250_000_000) // 250ms
+            if let existing = queue.sync(execute: { locks[txid] }) {
+                return existing
+            }
+        }
+
+        throw SPVError.transactionBroadcastFailed(
+            "InstantSend lock timeout after \(Int(timeout))s for txid \(txid.hexString)"
+        )
+    }
+}