Boltz-refactoring (block-core#695)

* Refactor Boltz swap implementation: remove unused code and add new storage service

* removed obsolete service

* Add BoltzConfiguration class for swap service settings

* Refactor Boltz integration: move models and services to Angor.Shared.Integration.Lightning namespace

* Refactor Boltz integration: move DTOs to Angor.Shared.Integration.Lightning and implement XunitLogger for test output

* Update dependencies: add NBitcoin.Secp256k1 package and clean up unused using directives in test files

* Add BoltzClaimService and BoltzMusig2 for cooperative claiming functionality

* Add BoltzSwapStorageService for managing swaps in localStorage

* Add AddressPollingService for monitoring incoming funds and refactor MempoolMonitoringService to use it

* Enhance investment process feedback: add dynamic status messages during payment processing and streamline transaction submission

* Refactor InvestInProject method to simplify navigation and remove wallet check

* Refactor project stage percentage calculations to use decimal representation and ensure consistency across services

* Remove unused MoreLinq dependency from BuildRecoveryTransaction.cs

* Skip integration test requiring local boltz server

* Update integration tests: enable FullReverseSwapFlow test and fix exception type in MempoolMonitoringServiceTests

Author: DavidGershony

src/Angor.Test/MempoolMonitoringServiceTests.cs

@@ -205,7 +205,7 @@ public async Task MonitorAddressForFundsAsync_WhenCanceled_ThrowsOperationCancel
             });
 
         // Act & Assert
-        await Assert.ThrowsAsync<TaskCanceledException>(() =>
+        await Assert.ThrowsAsync<OperationCanceledException>(() =>
             _sut.MonitorAddressForFundsAsync(
                 address,
                 requiredAmount,

src/Angor/Avalonia/Angor.Avalonia.sln

@@ -42,6 +42,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Angor.Test", "..\..\Angor.T
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AngorApp.Tests", "AngorApp.Tests\AngorApp.Tests.csproj", "{E7997F04-DA79-4F76-A617-499EBC590B71}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Angor.Client", "..\Client\Angor.Client.csproj", "{0E91C19D-387F-4F60-87DE-54F0BB78814E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -92,6 +94,10 @@ Global
 		{E7997F04-DA79-4F76-A617-499EBC590B71}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E7997F04-DA79-4F76-A617-499EBC590B71}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E7997F04-DA79-4F76-A617-499EBC590B71}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0E91C19D-387F-4F60-87DE-54F0BB78814E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0E91C19D-387F-4F60-87DE-54F0BB78814E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0E91C19D-387F-4F60-87DE-54F0BB78814E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E91C19D-387F-4F60-87DE-54F0BB78814E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -108,6 +114,7 @@ Global
 		{0F80E799-F731-4CA1-8FBC-E6BF82465845} = {E68996BA-A784-4A8A-B0BB-AFD4C8F705AE}
 		{5DCEA28A-CB30-4F4F-A922-61C14F10D486} = {43B28F35-B0E0-4F28-9F40-C2430B4C8426}
 		{E7997F04-DA79-4F76-A617-499EBC590B71} = {43B28F35-B0E0-4F28-9F40-C2430B4C8426}
+		{0E91C19D-387F-4F60-87DE-54F0BB78814E} = {4B0A97D7-BA72-4208-94B6-707935986EDC}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {83CB65B8-011F-4ED7-BCD3-A6CFA935EF7E}

src/Angor/Avalonia/Angor.Sdk.Tests/Funding/Investor/Operations/AddressPollingServiceTests.cs

@@ -0,0 +1,354 @@
+using Angor.Shared.Models;
+using Angor.Shared.Services;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Angor.Sdk.Tests.Funding.Investor.Operations;
+
+/// <summary>
+/// Unit tests for AddressPollingService (IAddressPollingService).
+/// Tests the core polling loop behavior that was previously inside MempoolMonitoringService.MonitorAddressForFundsAsync.
+/// These tests lock down the behavior before the refactor so we can prove no regression.
+/// </summary>
+public class AddressPollingServiceTests
+{
+    private readonly Mock<IIndexerService> _mockIndexerService;
+    private readonly AddressPollingService _sut;
+
+    public AddressPollingServiceTests()
+    {
+        _mockIndexerService = new Mock<IIndexerService>();
+        _sut = new AddressPollingService(
+            _mockIndexerService.Object,
+            new NullLogger<AddressPollingService>());
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WhenSufficientFundsOnFirstPoll_ReturnsUtxosImmediately()
+    {
+        // Arrange
+        var address = "tb1qtest_immediate";
+        var requiredSats = 100_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 150_000, "txid1", 0)
+        };
+
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(utxos);
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.Equal(150_000, result[0].value);
+
+        _mockIndexerService.Verify(
+            x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()),
+            Times.Once);
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WhenFundsArriveOnSecondPoll_RetriesAndReturns()
+    {
+        // Arrange
+        var address = "tb1qtest_retry";
+        var requiredSats = 100_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 120_000, "txid1", 0)
+        };
+
+        var callCount = 0;
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(() =>
+            {
+                callCount++;
+                // First call returns empty, second call returns funds
+                return callCount >= 2 ? utxos : new List<UtxoData>();
+            });
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.Equal(120_000, result[0].value);
+        Assert.True(callCount >= 2, "Should have polled at least twice");
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WhenCancelled_ReturnsEmptyList()
+    {
+        // Arrange
+        var address = "tb1qtest_cancel";
+        var requiredSats = 100_000L;
+        var cts = new CancellationTokenSource();
+
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(() =>
+            {
+                // Cancel after first poll returns no funds
+                cts.Cancel();
+                return new List<UtxoData>();
+            });
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(30), TimeSpan.FromMilliseconds(50),
+            cts.Token);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WhenTimeout_ReturnsEmptyList()
+    {
+        // Arrange
+        var address = "tb1qtest_timeout";
+        var requiredSats = 100_000L;
+
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(new List<UtxoData>());
+
+        // Act - use a very short timeout
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(30),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WithMultipleUtxos_SumsCorrectly()
+    {
+        // Arrange
+        var address = "tb1qtest_multi";
+        var requiredSats = 200_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 80_000, "txid1", 0),
+            CreateUtxo(address, 70_000, "txid2", 0),
+            CreateUtxo(address, 60_000, "txid3", 0)
+            // Total: 210_000 >= 200_000
+        };
+
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(utxos);
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(3, result.Count);
+        Assert.Equal(210_000, result.Sum(u => u.value));
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WithInsufficientMultipleUtxos_ContinuesPolling()
+    {
+        // Arrange
+        var address = "tb1qtest_insufficient";
+        var requiredSats = 200_000L;
+        var insufficientUtxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 50_000, "txid1", 0),
+            CreateUtxo(address, 30_000, "txid2", 0)
+            // Total: 80_000 < 200_000
+        };
+        var sufficientUtxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 50_000, "txid1", 0),
+            CreateUtxo(address, 30_000, "txid2", 0),
+            CreateUtxo(address, 150_000, "txid3", 0)
+            // Total: 230_000 >= 200_000
+        };
+
+        var callCount = 0;
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(() =>
+            {
+                callCount++;
+                return callCount >= 3 ? sufficientUtxos : insufficientUtxos;
+            });
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(3, result.Count);
+        Assert.Equal(230_000, result.Sum(u => u.value));
+        Assert.True(callCount >= 3);
+    }
+
+    [Fact]
+    public async Task WaitForFunds_OnlyCountsMempoolUtxos_IgnoresConfirmed()
+    {
+        // Arrange
+        var address = "tb1qtest_mempool_only";
+        var requiredSats = 100_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 90_000, "txid1", 0, blockIndex: 500), // Confirmed - should be ignored
+            CreateUtxo(address, 110_000, "txid2", 0, blockIndex: 0)   // Mempool - should be counted
+        };
+
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(utxos);
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.Equal(110_000, result[0].value);
+        Assert.Equal(0, result[0].blockIndex); // Only mempool UTXOs returned
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WhenIndexerThrows_ContinuesPolling()
+    {
+        // Arrange
+        var address = "tb1qtest_error_recovery";
+        var requiredSats = 100_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 150_000, "txid1", 0)
+        };
+
+        var callCount = 0;
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(() =>
+            {
+                callCount++;
+                if (callCount == 1)
+                    throw new HttpRequestException("Network error");
+                return utxos;
+            });
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.True(callCount >= 2, "Should have retried after error");
+    }
+
+    [Fact]
+    public async Task WaitForFunds_WhenIndexerReturnsNull_ContinuesPolling()
+    {
+        // Arrange
+        var address = "tb1qtest_null";
+        var requiredSats = 100_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 150_000, "txid1", 0)
+        };
+
+        var callCount = 0;
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(() =>
+            {
+                callCount++;
+                if (callCount == 1)
+                    return null;
+                return utxos;
+            });
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.True(callCount >= 2);
+    }
+
+    [Fact]
+    public async Task WaitForFunds_ExactAmountMatch_ReturnsUtxos()
+    {
+        // Arrange
+        var address = "tb1qtest_exact";
+        var requiredSats = 100_000L;
+        var utxos = new List<UtxoData>
+        {
+            CreateUtxo(address, 100_000, "txid1", 0) // Exactly the required amount
+        };
+
+        _mockIndexerService
+            .Setup(x => x.FetchUtxoAsync(address, It.IsAny<int>(), It.IsAny<int>()))
+            .ReturnsAsync(utxos);
+
+        // Act
+        var result = await _sut.WaitForFundsAsync(
+            address, requiredSats,
+            TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(50),
+            CancellationToken.None);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.Equal(100_000, result[0].value);
+    }
+
+    #region Helper Methods
+
+    private static UtxoData CreateUtxo(string address, long value, string txId, int outputIndex, int blockIndex = 0)
+    {
+        return new UtxoData
+        {
+            address = address,
+            value = value,
+            outpoint = new Outpoint(txId, outputIndex),
+            scriptHex = "",
+            blockIndex = blockIndex
+        };
+    }
+
+    #endregion
+}
+