bump

BTCPayServer.Tests/docker-compose.yml

@@ -56,7 +56,7 @@ services:
       - bitcoind
 
   litecoin-nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.0.42
+    image: nicolasdorier/nbxplorer:1.0.0.43
     ports:
       - "32839:32839"
     expose: 

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.61</Version>
+		<Version>1.0.0.62</Version>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -140,7 +140,128 @@ namespace BTCPayServer.HostedServices
         private async Task UpdateInvoice(UpdateInvoiceContext context)
         {
             var invoice = context.Invoice;
-            //Fetch unknown payments
+            if (invoice.Status == "new" && invoice.ExpirationTime < DateTimeOffset.UtcNow)
+            {
+                context.MarkDirty();
+                await _InvoiceRepository.UnaffectAddress(invoice.Id);
+
+                context.Events.Add(new InvoiceStatusChangedEvent(invoice, "expired"));
+                invoice.Status = "expired";
+            }
+
+            foreach (NetworkCoins coins in await GetCoinsPerNetwork(context, invoice))
+            {
+                bool dirtyAddress = false;
+                if (coins.State != null)
+                    context.ModifiedKnownStates.AddOrReplace(coins.Strategy.Network, coins.State);
+                var alreadyAccounted = new HashSet<OutPoint>(invoice.Payments.Select(p => p.Outpoint));
+                foreach (var coin in coins.Coins.Where(c => !alreadyAccounted.Contains(c.Outpoint)))
+                {
+                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin, coins.Strategy.Network.CryptoCode).ConfigureAwait(false);
+                    invoice.Payments.Add(payment);
+                    context.Events.Add(new InvoicePaymentEvent(invoice.Id));
+                    dirtyAddress = true;
+                }
+                var network = coins.Strategy.Network;
+                var cryptoData = invoice.GetCryptoData(network);
+                var cryptoDataAll = invoice.GetCryptoData();
+                var accounting = cryptoData.Calculate();
+
+                if (invoice.Status == "new" || invoice.Status == "expired")
+                {
+                    var totalPaid = (await GetPaymentsWithTransaction(network, invoice)).Select(p => p.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    if (totalPaid >= accounting.TotalDue)
+                    {
+                        if (invoice.Status == "new")
+                        {
+                            context.Events.Add(new InvoiceStatusChangedEvent(invoice, "paid"));
+                            invoice.Status = "paid";
+                            invoice.ExceptionStatus = null;
+                            await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                            context.MarkDirty();
+                        }
+                        else if (invoice.Status == "expired")
+                        {
+                            invoice.ExceptionStatus = "paidLate";
+                            context.MarkDirty();
+                        }
+                    }
+
+                    if (totalPaid > accounting.TotalDue && invoice.ExceptionStatus != "paidOver")
+                    {
+                        invoice.ExceptionStatus = "paidOver";
+                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        context.MarkDirty();
+                    }
+
+                    if (totalPaid < accounting.TotalDue && invoice.Payments.Count != 0 && invoice.ExceptionStatus != "paidPartial")
+                    {
+                        invoice.ExceptionStatus = "paidPartial";
+                        context.MarkDirty();
+                        if (dirtyAddress)
+                        {
+                            var address = await _Wallet.ReserveAddressAsync(coins.Strategy);
+                            Logs.PayServer.LogInformation("Generate new " + address);
+                            await _InvoiceRepository.NewAddress(invoice.Id, address, network);
+                        }
+                    }
+                }
+
+                if (invoice.Status == "paid")
+                {
+                    var transactions = await GetPaymentsWithTransaction(network, invoice);
+                    if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
+                    {
+                        transactions = transactions.Where(t => t.Confirmations >= 1 || !t.Transaction.RBF);
+                    }
+                    else if (invoice.SpeedPolicy == SpeedPolicy.MediumSpeed)
+                    {
+                        transactions = transactions.Where(t => t.Confirmations >= 1);
+                    }
+                    else if (invoice.SpeedPolicy == SpeedPolicy.LowSpeed)
+                    {
+                        transactions = transactions.Where(t => t.Confirmations >= 6);
+                    }
+
+                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+
+                    if (// Is after the monitoring deadline
+                       (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
+                       &&
+                       // And not enough amount confirmed
+                       (totalConfirmed < accounting.TotalDue))
+                    {
+                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        context.Events.Add(new InvoiceStatusChangedEvent(invoice, "invalid"));
+                        invoice.Status = "invalid";
+                        context.MarkDirty();
+                    }
+                    else if (totalConfirmed >= accounting.TotalDue)
+                    {
+                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        context.Events.Add(new InvoiceStatusChangedEvent(invoice, "confirmed"));
+                        invoice.Status = "confirmed";
+                        context.MarkDirty();
+                    }
+                }
+
+                if (invoice.Status == "confirmed")
+                {
+                    var transactions = await GetPaymentsWithTransaction(network, invoice);
+                    transactions = transactions.Where(t => t.Confirmations >= 6);
+                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    if (totalConfirmed >= accounting.TotalDue)
+                    {
+                        context.Events.Add(new InvoiceStatusChangedEvent(invoice, "complete"));
+                        invoice.Status = "complete";
+                        context.MarkDirty();
+                    }
+                }
+            }
+        }
+
+        private async Task<IEnumerable<NetworkCoins>> GetCoinsPerNetwork(UpdateInvoiceContext context, InvoiceEntity invoice)
+        {
             var strategies = invoice.GetDerivationStrategies(_NetworkProvider).ToArray();
             var getCoinsResponsesAsync = strategies
                                 .Select(d => _Wallet.GetCoins(d, context.KnownStates.TryGet(d.Network)))
@@ -151,125 +272,7 @@ namespace BTCPayServer.HostedServices
             {
                 response.Coins = response.Coins.Where(c => invoice.AvailableAddressHashes.Contains(c.ScriptPubKey.Hash.ToString() + response.Strategy.Network.CryptoCode)).ToArray();
             }
-            var coins = getCoinsResponses.Where(s => s.Coins.Length != 0).FirstOrDefault();
-            bool dirtyAddress = false;
-            if (coins != null)
-            {
-                if (coins.State != null)
-                    context.ModifiedKnownStates.Add(coins.Strategy.Network, coins.State);
-                var alreadyAccounted = new HashSet<OutPoint>(invoice.Payments.Select(p => p.Outpoint));
-                foreach (var coin in coins.Coins.Where(c => !alreadyAccounted.Contains(c.Outpoint)))
-                {
-                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin, coins.Strategy.Network.CryptoCode).ConfigureAwait(false);
-                    invoice.Payments.Add(payment);
-                    context.Events.Add(new InvoicePaymentEvent(invoice.Id));
-                    dirtyAddress = true;
-                }
-            }
-            //////
-            var network = coins?.Strategy?.Network ?? _NetworkProvider.GetNetwork(invoice.GetCryptoData().First().Key);
-            var cryptoData = invoice.GetCryptoData(network);
-            var cryptoDataAll = invoice.GetCryptoData();
-            var accounting = cryptoData.Calculate();
-            if (invoice.Status == "new" && invoice.ExpirationTime < DateTimeOffset.UtcNow)
-            {
-                context.MarkDirty();
-                await _InvoiceRepository.UnaffectAddress(invoice.Id);
-
-                context.Events.Add(new InvoiceStatusChangedEvent(invoice, "expired"));
-                invoice.Status = "expired";
-            }
-
-            if (invoice.Status == "new" || invoice.Status == "expired")
-            {
-                var totalPaid = (await GetPaymentsWithTransaction(network, invoice)).Select(p => p.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                if (totalPaid >= accounting.TotalDue)
-                {
-                    if (invoice.Status == "new")
-                    {
-                        context.Events.Add(new InvoiceStatusChangedEvent(invoice, "paid"));
-                        invoice.Status = "paid";
-                        invoice.ExceptionStatus = null;
-                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        context.MarkDirty();
-                    }
-                    else if (invoice.Status == "expired")
-                    {
-                        invoice.ExceptionStatus = "paidLate";
-                        context.MarkDirty();
-                    }
-                }
-
-                if (totalPaid > accounting.TotalDue && invoice.ExceptionStatus != "paidOver")
-                {
-                    invoice.ExceptionStatus = "paidOver";
-                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    context.MarkDirty();
-                }
-
-                if (totalPaid < accounting.TotalDue && invoice.Payments.Count != 0 && invoice.ExceptionStatus != "paidPartial")
-                {
-                    invoice.ExceptionStatus = "paidPartial";
-                    context.MarkDirty();
-                    if (dirtyAddress)
-                    {
-                        var address = await _Wallet.ReserveAddressAsync(coins.Strategy);
-                        Logs.PayServer.LogInformation("Generate new " + address);
-                        await _InvoiceRepository.NewAddress(invoice.Id, address, network);
-                    }
-                }
-            }
-
-            if (invoice.Status == "paid")
-            {
-                var transactions = await GetPaymentsWithTransaction(network, invoice);
-                if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
-                {
-                    transactions = transactions.Where(t => t.Confirmations >= 1 || !t.Transaction.RBF);
-                }
-                else if (invoice.SpeedPolicy == SpeedPolicy.MediumSpeed)
-                {
-                    transactions = transactions.Where(t => t.Confirmations >= 1);
-                }
-                else if (invoice.SpeedPolicy == SpeedPolicy.LowSpeed)
-                {
-                    transactions = transactions.Where(t => t.Confirmations >= 6);
-                }
-
-                var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-
-                if (// Is after the monitoring deadline
-                   (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
-                   &&
-                   // And not enough amount confirmed
-                   (totalConfirmed < accounting.TotalDue))
-                {
-                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    context.Events.Add(new InvoiceStatusChangedEvent(invoice, "invalid"));
-                    invoice.Status = "invalid";
-                    context.MarkDirty();
-                }
-                else if (totalConfirmed >= accounting.TotalDue)
-                {
-                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    context.Events.Add(new InvoiceStatusChangedEvent(invoice, "confirmed"));
-                    invoice.Status = "confirmed";
-                    context.MarkDirty();
-                }
-            }
-
-            if (invoice.Status == "confirmed")
-            {
-                var transactions = await GetPaymentsWithTransaction(network, invoice);
-                transactions = transactions.Where(t => t.Confirmations >= 6);
-                var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                if (totalConfirmed >= accounting.TotalDue)
-                {
-                    context.Events.Add(new InvoiceStatusChangedEvent(invoice, "complete"));
-                    invoice.Status = "complete";
-                    context.MarkDirty();
-                }
-            }
+            return getCoinsResponses.Where(s => s.Coins.Length != 0).ToArray();
         }
 
         private async Task<IEnumerable<AccountedPaymentEntity>> GetPaymentsWithTransaction(BTCPayNetwork network, InvoiceEntity invoice)

BTCPayServer/Services/Wallets/BTCPayWallet.cs

@@ -17,7 +17,7 @@ namespace BTCPayServer.Services.Wallets
         public uint256 UnconfirmedHash { get; set; }
         public uint256 ConfirmedHash { get; set; }
     }
-    public class GetCoinsResult
+    public class NetworkCoins
     {
         public Coin[] Coins { get; set; }
         public KnownState State { get; set; }
@@ -26,16 +26,12 @@ namespace BTCPayServer.Services.Wallets
     public class BTCPayWallet
     {
         private ExplorerClientProvider _Client;
-        ApplicationDbContextFactory _DBFactory;
 
-        public BTCPayWallet(ExplorerClientProvider client, ApplicationDbContextFactory factory)
+        public BTCPayWallet(ExplorerClientProvider client)
         {
             if (client == null)
                 throw new ArgumentNullException(nameof(client));
-            if (factory == null)
-                throw new ArgumentNullException(nameof(factory));
             _Client = client;
-            _DBFactory = factory;
         }
 
 
@@ -58,14 +54,14 @@ namespace BTCPayServer.Services.Wallets
             return client.GetTransactionAsync(txId, cancellation);
         }
 
-        public async Task<GetCoinsResult> GetCoins(DerivationStrategy strategy, KnownState state, CancellationToken cancellation = default(CancellationToken))
+        public async Task<NetworkCoins> GetCoins(DerivationStrategy strategy, KnownState state, CancellationToken cancellation = default(CancellationToken))
         {
             var client = _Client.GetExplorerClient(strategy.Network);
             if (client == null)
-                return new GetCoinsResult() { Coins = new Coin[0], State = null, Strategy = strategy };
+                return new NetworkCoins() { Coins = new Coin[0], State = null, Strategy = strategy };
             var changes = await client.SyncAsync(strategy.DerivationStrategyBase, state?.ConfirmedHash, state?.UnconfirmedHash, true, cancellation).ConfigureAwait(false);
             var utxos = changes.Confirmed.UTXOs.Concat(changes.Unconfirmed.UTXOs).Select(c => c.AsCoin()).ToArray();
-            return new GetCoinsResult()
+            return new NetworkCoins()
             {
                 Coins = utxos,
                 State = new KnownState() { ConfirmedHash = changes.Confirmed.Hash, UnconfirmedHash = changes.Unconfirmed.Hash },
@@ -80,6 +76,7 @@ namespace BTCPayServer.Services.Wallets
             return Task.WhenAll(tasks);
         }
 
+
         public async Task<Money> GetBalance(DerivationStrategy derivationStrategy)
         {
             var client = _Client.GetExplorerClient(derivationStrategy.Network);