test(swift-sdk): mid flight added wallet integration test

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

@@ -0,0 +1,148 @@
+import Foundation
+import XCTest
+import DashSDKFFI
+@testable import SwiftDashSDK
+
+/// Wallet imported MID-sync.
+final class SpvManyTxMidSyncBackfillIntegrationTests: IntegrationTestCase {
+    /// Number of transactions / distinct funded addresses. Parameterized.
+    private let numTxs = 10
+
+    /// Funding amount per address, in DASH.
+    private let amountEachDash: Double = 0.001
+    private var amountEachDuffs: UInt64 { UInt64(amountEachDash * 1e8) }
+
+    func testManyTxImportedMidSyncBackfillsAllHistory() async throws {
+        let mnemonic = try Mnemonic.generate(wordCount: 24)
+
+        // 1. Derive N distinct external receive addresses from the KeyWallet
+        //    layer (regtest-encoded — the manager's network drives encoding).
+        let km = try WalletManager(network: .regtest)
+        let walletId = try km.addWallet(mnemonic: mnemonic)
+        let addresses = try Self.deriveExternalAddresses(
+            manager: km, walletId: walletId, count: numTxs
+        )
+
+        // One funding tx per block.
+        for i in 0..<numTxs {
+            _ = try await env.coreRPC.sendToAddress(
+                amount: amountEachDash, address: addresses[i]
+            )
+            _ = try await env.mine(1)
+        }
+
+        let expectedTotal = UInt64(numTxs) * amountEachDuffs
+
+        // Start the SPV client EMPTY, then wait until it is ~20% synced so the
+        // wallet is imported genuinely mid-sync.
+        try await env.walletManager.startSpv(config: env.spvConfig)
+        let tipHeight = try await env.coreRPC.getBlockCount()
+        try await env.walletManager.waitUntilUpToDate(
+            height: tipHeight / 5,
+            timeout: 180
+        )
+
+        // Import the funded wallet into the still-syncing client, birthHeight
+        //   0 so it is contractually expected to scan history from genesis.
+        let imported = try await env.walletManager.createWallet(
+            mnemonic: mnemonic,
+            network: .regtest,
+            name: "many-tx",
+            createDefaultAccounts: true,
+            birthHeight: 0
+        )
+
+        // Wait until the wallet is fully synced, then check that the balance is
+        try await env.walletManager.waitUntilUpToDate(
+            height: try await env.coreRPC.getBlockCount(),
+            timeout: 180
+        )
+        _ = try? await Wait.until("balance reaches expected", timeout: 120, pollInterval: 0.5) {
+            try imported.balance().total == expectedTotal
+        }
+        let atFullSync = try imported.balance().total
+
+        XCTAssertEqual(
+            atFullSync,
+            expectedTotal,
+            "atFullSync=\(atFullSync) expected=\(expectedTotal)"
+        )
+    }
+
+    // MARK: - KeyWallet address enumeration
+
+    struct DerivationError: Error, CustomStringConvertible {
+        let description: String
+    }
+
+    /// Generate and return BIP-44 external (receive) addresses in
+    /// `[0, count)` from a KeyWallet `WalletManager` handle.
+    ///
+    /// `managed_wallet_get_bip_44_external_address_range` is a single Rust-side
+    /// call that generates addresses lazily if they don't yet exist, so it can
+    /// hand back the full 0..<count range regardless of the default gap limit —
+    /// no Swift-side derivation or gap-limit walking required.
+    private static func deriveExternalAddresses(
+        manager: WalletManager, walletId: Data, count: Int
+    ) throws -> [String] {
+        var error = FFIError()
+
+        guard let managedInfo = walletId.withUnsafeBytes({ raw in
+            wallet_manager_get_managed_wallet_info(
+                manager.ffiHandle,
+                raw.bindMemory(to: UInt8.self).baseAddress,
+                &error
+            )
+        }) else {
+            throw DerivationError(description: "wallet_manager_get_managed_wallet_info failed: \(Self.take(&error))")
+        }
+        defer { managed_wallet_info_free(managedInfo) }
+
+        // Non-owning: the manager retains ownership of the wallet handle.
+        guard let wallet = walletId.withUnsafeBytes({ raw in
+            wallet_manager_get_wallet(
+                manager.ffiHandle,
+                raw.bindMemory(to: UInt8.self).baseAddress,
+                &error
+            )
+        }) else {
+            throw DerivationError(description: "wallet_manager_get_wallet failed: \(Self.take(&error))")
+        }
+
+        var addressesOut: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>? = nil
+        var outCount = 0
+        let ok = managed_wallet_get_bip_44_external_address_range(
+            managedInfo,
+            wallet,
+            /* account_index */ 0,
+            /* start_index   */ 0,
+            /* end_index     */ UInt32(count),
+            &addressesOut,
+            &outCount,
+            &error
+        )
+        guard ok, let arr = addressesOut else {
+            throw DerivationError(description: "managed_wallet_get_bip_44_external_address_range failed: \(Self.take(&error))")
+        }
+        defer { address_array_free(arr, outCount) }
+
+        var result: [String] = []
+        result.reserveCapacity(outCount)
+        for i in 0..<outCount {
+            if let cstr = arr[i] {
+                result.append(String(cString: cstr))
+            }
+        }
+        return result
+    }
+
+    /// Read (and free) an `FFIError` message, returning a display string.
+    private static func take(_ error: inout FFIError) -> String {
+        guard let msg = error.message else { return "code \(error.code.rawValue)" }
+        defer {
+            error_message_free(msg)
+            error.message = nil
+        }
+        return String(cString: msg)
+    }
+}