test(swift-sdk): integration test framework against local dashmate devnet

Author: ZocoLini

packages/swift-sdk/Package.swift

@@ -28,12 +28,20 @@ let package = Package(
             linkerSettings: [.linkedFramework("SystemConfiguration")]
         ),
 
-        // Tests
+        // Unit tests (offline, hermetic)
         .testTarget(
             name: "SwiftDashSDKTests",
             dependencies: ["SwiftDashSDK"],
             path: "SwiftTests/SwiftDashSDKTests"
-        )
+        ),
+
+        // Integration tests against a local dashmate devnet.
+        // Gated by env var `RUN_INTEGRATION_TESTS=1`
+        .testTarget(
+            name: "SwiftDashSDKIntegrationTests",
+            dependencies: ["SwiftDashSDK"],
+            path: "SwiftTests/SwiftDashSDKIntegrationTests"
+        ),
     ],
     swiftLanguageModes: [.v6]
 )

packages/swift-sdk/SwiftTests/SwiftDashSDKIntegrationTests/Core/CoreSendIntegrationTests.swift

@@ -0,0 +1,78 @@
+import XCTest
+import SwiftData
+@testable import SwiftDashSDK
+
+final class CoreSendIntegrationTests: IntegrationTestCase {
+    private let fundingDash: Double = 0.5
+    private var fundingDuffs: UInt64 {
+        UInt64(fundingDash * 1e8)
+    }
+
+    func testWalletToWalletViaSpv() async throws {
+        try await env.ensureSPVStarted()
+        let alice = try await env.makeTestWallet(name: "core-send-alice")
+        let bob = try await env.makeTestWallet(name: "core-send-bob")
+
+        let aliceAddress = try alice.getCoreWallet().nextReceiveAddress()
+        _ = try await env.fund(address: aliceAddress, dash: fundingDash)
+        let bobAddress = try bob.getCoreWallet().nextReceiveAddress()
+        _ = try await env.fund(address: bobAddress, dash: fundingDash)
+        try await alice.waitForSpendable(exactly: fundingDuffs, timeout: 90)
+        try await bob.waitForSpendable(exactly: fundingDuffs, timeout: 90)
+
+        let iterations = 5
+        let amount: UInt64 = 100_000 // 0.001 DASH per hop
+
+        for i in 0 ..< iterations {
+            let aliceSends = (i % 2 == 0)
+            let sender = aliceSends ? alice: bob
+            let receiver = aliceSends ? bob: alice
+
+            let receiverBalanceBefore = try receiver.getPlatformWallet().balance().spendable
+            let recipientAddress = try receiver.getCoreWallet().nextReceiveAddress()
+
+            _ = try sender.getCoreWallet().sendToAddresses(
+                recipients: [(address: recipientAddress, amountDuffs: amount)]
+            )
+
+            try await Wait.until(
+                "receiver +\(amount) after iteration \(i)",
+                timeout: 60,
+                pollInterval: 0.01
+            ) {
+                try receiver.getPlatformWallet().balance().spendable
+                    == receiverBalanceBefore + amount
+            }
+        }
+
+        let aliceFinal = try alice.getPlatformWallet().balance().spendable
+        let bobFinal = try bob.getPlatformWallet().balance().spendable
+        XCTAssertLessThanOrEqual(aliceFinal + bobFinal, 2 * fundingDuffs)
+
+        // Validate via the SwiftData
+        let expectedTotalTxs = 2 + iterations
+        let aliceWalletId = alice.getPlatformWallet().walletId
+        let bobWalletId = bob.getPlatformWallet().walletId
+        let container = env.modelContainer
+
+        try await MainActor.run {
+            let context = ModelContext(container)
+            let allTxCount = try context.fetchCount(FetchDescriptor<PersistentTransaction>())
+            XCTAssertEqual(allTxCount, expectedTotalTxs)
+
+            let aliceTxoCount = try context.fetchCount(FetchDescriptor<PersistentTxo>(
+                predicate: #Predicate<PersistentTxo>{
+                    $0.walletId == aliceWalletId
+                }
+            ))
+            let bobTxoCount = try context.fetchCount(FetchDescriptor<PersistentTxo>(
+                predicate: #Predicate<PersistentTxo>{
+                    $0.walletId == bobWalletId
+                }
+            ))
+
+            XCTAssertEqual(aliceTxoCount, 1 + iterations)
+            XCTAssertEqual(bobTxoCount, 1 + iterations)
+        }
+    }
+}

packages/swift-sdk/SwiftTests/SwiftDashSDKIntegrationTests/Core/SpvRestartIntegrationTests.swift

@@ -0,0 +1,69 @@
+import XCTest
+import SwiftData
+@testable import SwiftDashSDK
+
+/// Verifies that the persisted wallet state survives an SPV stop/start
+/// cycle
+final class SpvRestartIntegrationTests: IntegrationTestCase {
+    private let fundingDash: Double = 0.5
+    private var fundingDuffs: UInt64 { UInt64(fundingDash * 1e8) }
+    private let amount: UInt64 = 100_000
+
+    func testTxosSurviveSpvRestart() async throws {
+        try await env.ensureSPVStarted()
+        let alice = try await env.makeTestWallet(name: "spv-restart-alice")
+        let bob = try await env.makeTestWallet(name: "spv-restart-bob")
+
+        let aliceAddress = try alice.getCoreWallet().nextReceiveAddress()
+        _ = try await env.fund(address: aliceAddress, dash: fundingDash)
+
+        let bobAddress = try bob.getCoreWallet().nextReceiveAddress()
+        _ = try await env.fund(address: bobAddress, dash: fundingDash)
+
+        try await alice.waitForSpendable(exactly: fundingDuffs, timeout: 90)
+        try await bob.waitForSpendable(exactly: fundingDuffs, timeout: 90)
+
+        try await sendAndConfirm(from: alice, to: bob)
+        try await env.restartSPV()
+        try await sendAndConfirm(from: alice, to: bob)
+
+        let aliceWalletId = alice.getPlatformWallet().walletId
+        let bobWalletId = bob.getPlatformWallet().walletId
+        let container = env.modelContainer
+
+        try await MainActor.run {
+            let context = ModelContext(container)
+
+            let aliceTxoCount = try context.fetchCount(FetchDescriptor<PersistentTxo>(
+                predicate: #Predicate<PersistentTxo> { $0.walletId == aliceWalletId }
+            ))
+            let bobTxoCount = try context.fetchCount(FetchDescriptor<PersistentTxo>(
+                predicate: #Predicate<PersistentTxo> { $0.walletId == bobWalletId }
+            ))
+
+            XCTAssertEqual(aliceTxoCount, 3)
+            XCTAssertEqual(bobTxoCount, 3)
+        }
+    }
+
+    private func sendAndConfirm(
+        from sender: TestWalletWrapper,
+        to receiver: TestWalletWrapper
+    ) async throws {
+        let receiverBalanceBefore = try receiver.getPlatformWallet().balance().spendable
+        let recipientAddress = try receiver.getCoreWallet().nextReceiveAddress()
+
+        _ = try sender.getCoreWallet().sendToAddresses(
+            recipients: [(address: recipientAddress, amountDuffs: amount)]
+        )
+
+        try await Wait.until(
+            "receiver balance advances by \(amount)",
+            timeout: 60,
+            pollInterval: 0.01
+        ) {
+            try receiver.getPlatformWallet().balance().spendable
+                == receiverBalanceBefore + amount
+        }
+    }
+}

packages/swift-sdk/SwiftTests/SwiftDashSDKIntegrationTests/Platform/SDKBootstrapIntegrationTests.swift

@@ -0,0 +1,9 @@
+import XCTest
+@testable import SwiftDashSDK
+
+/// Placeholder until real Platform-side integration coverage lands
+final class SDKBootstrapIntegrationTests: IntegrationTestCase {
+    func testSDKInitializes() {
+        _ = env.sdk
+    }
+}

packages/swift-sdk/SwiftTests/SwiftDashSDKIntegrationTests/Support/CoreRPCClient.swift

@@ -0,0 +1,140 @@
+import Foundation
+
+/// Minimal JSON-RPC client for dashd, covering only the calls the
+/// integration framework needs.
+struct CoreRPCClient {
+    private(set) var url: URL
+    let username: String
+    let password: String
+
+    init(port: Int, username: String, password: String) {
+        var components = URLComponents()
+        components.scheme = "http"
+        components.host = "127.0.0.1"
+        components.port = port
+        guard let url = components.url else {
+            preconditionFailure("Invalid Core RPC port: \(port)")
+        }
+        self.url = url
+        self.username = username
+        self.password = password
+    }
+
+    // MARK: - Typed methods
+
+    /// Throws RPC error -32601 if dashd was built without the miner.
+    @discardableResult
+    func generateToAddress(count: Int, address: String) async throws -> [String] {
+        try await call("generatetoaddress", params: [.int(count), .string(address)])
+    }
+
+    func getNewAddress(walletName: String = "main") async throws -> String {
+        try await wallet(walletName).call("getnewaddress")
+    }
+
+    /// `amount` is in DASH (not duffs). Returns the txid.
+    @discardableResult
+    func sendToAddress(amount: Double, address: String, walletName: String = "main") async throws -> String {
+        try await wallet(walletName).call(
+            "sendtoaddress",
+            params: [.string(address), .double(amount)]
+        )
+    }
+
+    /// Switches to the per-wallet RPC endpoint (`/wallet/<name>`).
+    func wallet(_ name: String) -> CoreRPCClient {
+        var copy = self
+        copy.url = url.appendingPathComponent("wallet").appendingPathComponent(name)
+        return copy
+    }
+
+    // MARK: - Generic JSON-RPC
+
+    enum Param: Sendable {
+        case string(String)
+        case int(Int)
+        case double(Double)
+    }
+
+    enum RPCError: Error, CustomStringConvertible {
+        case http(Int)
+        case rpc(code: Int, message: String)
+        case decode(String)
+
+        var description: String {
+            switch self {
+            case let .http(code): return "HTTP \(code)"
+            case let .rpc(code, msg): return "RPC error \(code): \(msg)"
+            case let .decode(msg): return "Decode error: \(msg)"
+            }
+        }
+    }
+
+    func call<T: Decodable>(_ method: String, params: [Param] = []) async throws -> T {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let credentials = "\(username):\(password)".data(using: .utf8)!.base64EncodedString()
+        request.setValue("Basic \(credentials)", forHTTPHeaderField: "Authorization")
+
+        let body: [String: Any] = [
+            "jsonrpc": "1.0",
+            "id": "swift-integration",
+            "method": method,
+            "params": encodeParams(params),
+        ]
+        request.httpBody = try JSONSerialization.data(withJSONObject: body)
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+        // dashd returns the RPC error in the body even on 500; only
+        // bail on HTTP errors if we can't parse the JSON-RPC body.
+        if let http = response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
+            if let decoded = try? decodeRPCResponse(data, T.self) {
+                return try unwrap(decoded)
+            }
+            throw RPCError.http(http.statusCode)
+        }
+        let decoded = try decodeRPCResponse(data, T.self)
+        return try unwrap(decoded)
+    }
+
+    private func decodeRPCResponse<T: Decodable>(_ data: Data, _: T.Type) throws -> RPCResponse<T> {
+        do {
+            return try JSONDecoder().decode(RPCResponse<T>.self, from: data)
+        } catch {
+            let raw = String(data: data, encoding: .utf8) ?? "<non-utf8>"
+            throw RPCError.decode("\(error) — body: \(raw)")
+        }
+    }
+
+    private func unwrap<T: Decodable>(_ response: RPCResponse<T>) throws -> T {
+        if let error = response.error {
+            throw RPCError.rpc(code: error.code, message: error.message)
+        }
+        guard let result = response.result else {
+            throw RPCError.decode("RPC response had neither `result` nor `error`")
+        }
+        return result
+    }
+
+    private func encodeParams(_ params: [Param]) -> [Any] {
+        params.map { param -> Any in
+            switch param {
+            case let .string(s): return s
+            case let .int(i): return i
+            case let .double(d): return d
+            }
+        }
+    }
+
+    private struct RPCResponse<T: Decodable>: Decodable {
+        let result: T?
+        let error: RPCErrorBody?
+    }
+
+    private struct RPCErrorBody: Decodable {
+        let code: Int
+        let message: String
+    }
+}

packages/swift-sdk/SwiftTests/SwiftDashSDKIntegrationTests/Support/IntegrationTestCase.swift

@@ -0,0 +1,43 @@
+import Foundation
+import XCTest
+
+open class IntegrationTestCase: XCTestCase {
+    private(set) var env: IntegrationTestEnv!
+
+    // XCTest serialises class-level setUps; only one path touches
+    // this latch.
+    nonisolated(unsafe) private static var bootstrapResult: Result<IntegrationTestEnv, Error>?
+
+    open override func setUp() async throws {
+        try await super.setUp()
+        try skipIfDisabled()
+        env = try await Self.sharedEnv()
+    }
+
+    open override func tearDown() async throws {
+        env?.purgeStoredMnemonics()
+        try await super.tearDown()
+    }
+
+    private func skipIfDisabled() throws {
+        let enabled = ProcessInfo.processInfo.environment["RUN_INTEGRATION_TESTS"] == "1"
+        try XCTSkipUnless(
+            enabled,
+            "Integration tests skipped — set RUN_INTEGRATION_TESTS=1 to enable"
+        )
+    }
+
+    private static func sharedEnv() async throws -> IntegrationTestEnv {
+        if let cached = bootstrapResult {
+            return try cached.get()
+        }
+        do {
+            let env = try await IntegrationTestEnv.bootstrap()
+            bootstrapResult = .success(env)
+            return env
+        } catch {
+            bootstrapResult = .failure(error)
+            throw error
+        }
+    }
+}