fix bug happening if only btc is supported

BTCPayServer.Tests/UnitTest1.cs

@@ -629,11 +629,11 @@ namespace BTCPayServer.Tests
                 Assert.Equal("new", invoice.Status);
                 Assert.False((bool)((JValue)invoice.ExceptionStatus).Value);
 
-                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime));
-                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime + TimeSpan.FromDays(1)));
-                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5)));
-                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime));
-                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime - TimeSpan.FromDays(1)));
+                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime));
+                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime + TimeSpan.FromDays(2)));
+                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime - TimeSpan.FromDays(5)));
+                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime + TimeSpan.FromDays(1.0)));
+                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime - TimeSpan.FromDays(1)));
 
 
                 var firstPayment = Money.Coins(0.04m);

BTCPayServer/BTCPayNetwork.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
@@ -63,13 +64,13 @@ namespace BTCPayServer
         public string CryptoImagePath { get; set; }
         public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
 
-
         public BTCPayDefaultSettings DefaultSettings { get; set; }
         public KeyPath CoinType { get; internal set; }
+        public int MaxTrackedConfirmation { get; internal set; } = 7;
 
         public override string ToString()
         {
             return CryptoCode;
-        }
+        }        
     }
 }

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.1.26</Version>
+		<Version>1.0.1.33</Version>
     <NoWarn>NU1701</NoWarn>
   </PropertyGroup>
   <ItemGroup>

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -239,6 +239,7 @@ namespace BTCPayServer.Controllers
             try
             {
                 leases.Add(_EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceNewAddressEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
                 leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
                 while (true)
                 {

BTCPayServer/Controllers/StoresController.cs

@@ -219,7 +219,7 @@ namespace BTCPayServer.Controllers
                 {
                     var strategy = GetDirectDerivationStrategy(store, network);
                     var strategyBase = GetDerivationStrategy(store, network);
-                    if (!await hw.SupportDerivation(network, strategy))
+                    if (strategy == null || !await hw.SupportDerivation(network, strategy))
                     {
                         throw new Exception($"This store is not configured to use this ledger");
                     }
@@ -238,12 +238,11 @@ namespace BTCPayServer.Controllers
                     var change = wallet.GetChangeAddressAsync(strategyBase);
                     var unspentCoins = await wallet.GetUnspentCoins(strategyBase);
                     var changeAddress = await change;
-                    unspentCoins.Item2.TryAdd(changeAddress.Item1.ScriptPubKey, changeAddress.Item2);
-                    var transaction = await hw.SendToAddress(strategy, unspentCoins.Item1, network,
+                    var transaction = await hw.SendToAddress(strategy, unspentCoins, network,
                                             new[] { (destinationAddress as IDestination, amountBTC, subsctractFeesValue) },
                                             feeRateValue,
                                             changeAddress.Item1,
-                                            unspentCoins.Item2);
+                                            changeAddress.Item2);
                     try
                     {
                         var broadcastResult = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { transaction });
@@ -256,6 +255,7 @@ namespace BTCPayServer.Controllers
                     {
                         throw new Exception("Error while broadcasting: " + ex.Message);
                     }
+                    wallet.InvalidateCache(strategyBase);
                     result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
                 }
             }
@@ -312,10 +312,10 @@ namespace BTCPayServer.Controllers
             var stores = await _Repo.GetStoresByUserId(GetUserId());
             var balances = stores
                                 .Select(s => s.GetDerivationStrategies(_NetworkProvider)
-                                              .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network),
-                                                            DerivationStrategy: d.DerivationStrategyBase))
+                                              .Select(d => ((Wallet: _WalletProvider.GetWallet(d.Network),
+                                                            DerivationStrategy: d.DerivationStrategyBase)))
                                               .Where(_ => _.Wallet != null)
-                                              .Select(async _ => (await _.Wallet.GetBalance(_.DerivationStrategy)).ToString() + " " + _.Wallet.Network.CryptoCode))
+                                              .Select(async _ => (await GetBalanceString(_)).ToString() + " " + _.Wallet.Network.CryptoCode))
                                 .ToArray();
 
             await Task.WhenAll(balances.SelectMany(_ => _));
@@ -333,6 +333,21 @@ namespace BTCPayServer.Controllers
             return View(result);
         }
 
+        private static async Task<string> GetBalanceString((BTCPayWallet Wallet, DerivationStrategyBase DerivationStrategy) _)
+        {
+            using (CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
+            {
+                try
+                {
+                    return (await _.Wallet.GetBalance(_.DerivationStrategy, cts.Token)).ToString();
+                }
+                catch
+                {
+                    return "--";
+                }
+            }
+        }
+
         [HttpGet]
         [Route("{storeId}/delete")]
         public async Task<IActionResult> DeleteStore(string storeId)

BTCPayServer/EventAggregator.cs

@@ -88,7 +88,9 @@ namespace BTCPayServer
                 }
             }
 
-            Logs.Events.LogInformation(evt.ToString());
+            var log = evt.ToString();
+            if(!String.IsNullOrEmpty(log))
+                Logs.Events.LogInformation(log);
             foreach (var sub in actionList)
             {
                 try

BTCPayServer/Events/InvoiceNeedUpdateEvent.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceNeedUpdateEvent
+    {
+        public InvoiceNeedUpdateEvent(string invoiceId)
+        {
+            if (invoiceId == null)
+                throw new ArgumentNullException(nameof(invoiceId));
+            InvoiceId = invoiceId;
+        }
+
+        public string InvoiceId { get; set; }
+
+        public override string ToString()
+        {
+            return string.Empty;
+        }
+    }
+}

BTCPayServer/Events/InvoiceNewAddressEvent.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceNewAddressEvent
+    {
+        public InvoiceNewAddressEvent(string invoiceId, string address, BTCPayNetwork network)
+        {
+            Address = address;
+            InvoiceId = invoiceId;
+            Network = network;
+        }
+
+        public string Address { get; set; }
+        public string InvoiceId { get; set; }
+        public BTCPayNetwork Network { get; set; }
+        public override string ToString()
+        {
+            return $"{Network.CryptoCode}: New address {Address} for invoice {InvoiceId}";
+        }
+    }
+}

BTCPayServer/Events/TxOutReceivedEvent.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using NBitcoin;
-
-namespace BTCPayServer.Events
-{
-    public class TxOutReceivedEvent
-    {
-        public BTCPayNetwork Network { get; set; }
-        public Script ScriptPubKey { get; set; }
-
-        public override string ToString()
-        {
-            String address = ScriptPubKey.GetDestinationAddress(Network.NBitcoinNetwork)?.ToString() ?? ScriptPubKey.ToString();
-            return $"{address} received a transaction ({Network.CryptoCode})";
-        }
-    }
-}

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -29,9 +29,6 @@ namespace BTCPayServer.HostedServices
             {
 
             }
-
-            public Dictionary<BTCPayNetwork, KnownState> KnownStates { get; set; }
-            public Dictionary<BTCPayNetwork, KnownState> ModifiedKnownStates { get; set; } = new Dictionary<BTCPayNetwork, KnownState>();
             public InvoiceEntity Invoice { get; set; }
             public List<object> Events { get; set; } = new List<object>();
 
@@ -46,42 +43,19 @@ namespace BTCPayServer.HostedServices
 
         InvoiceRepository _InvoiceRepository;
         EventAggregator _EventAggregator;
-        BTCPayWalletProvider _WalletProvider;
         BTCPayNetworkProvider _NetworkProvider;
 
         public InvoiceWatcher(
-            IHostingEnvironment env,
             BTCPayNetworkProvider networkProvider,
             InvoiceRepository invoiceRepository,
-            EventAggregator eventAggregator,
-            BTCPayWalletProvider walletProvider)
+            EventAggregator eventAggregator)
         {
             PollInterval = TimeSpan.FromMinutes(1.0);
-            _WalletProvider = walletProvider ?? throw new ArgumentNullException(nameof(walletProvider));
             _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
             _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
             _NetworkProvider = networkProvider;
         }
-        CompositeDisposable leases = new CompositeDisposable();
-
-        async Task NotifyReceived(Script scriptPubKey, BTCPayNetwork network)
-        {
-            var invoice = await _InvoiceRepository.GetInvoiceIdFromScriptPubKey(scriptPubKey, network.CryptoCode);
-            if (invoice != null)
-            {
-                String address = scriptPubKey.GetDestinationAddress(network.NBitcoinNetwork)?.ToString() ?? scriptPubKey.ToString();
-                Logs.PayServer.LogInformation($"{address} is mapping to invoice {invoice}");
-                _WatchRequests.Add(invoice);
-            }
-        }
-
-        async Task NotifyBlock()
-        {
-            foreach (var invoice in await _InvoiceRepository.GetPendingInvoices())
-            {
-                _WatchRequests.Add(invoice);
-            }
-        }
+        CompositeDisposable leases = new CompositeDisposable();        
 
         private async Task UpdateInvoice(string invoiceId, CancellationToken cancellation)
         {
@@ -99,8 +73,7 @@ namespace BTCPayServer.HostedServices
                     var stateBefore = invoice.Status;
                     var updateContext = new UpdateInvoiceContext()
                     {
-                        Invoice = invoice,
-                        KnownStates = changes
+                        Invoice = invoice
                     };
                     await UpdateInvoice(updateContext).ConfigureAwait(false);
                     if (updateContext.Dirty)
@@ -116,11 +89,6 @@ namespace BTCPayServer.HostedServices
                         _EventAggregator.Publish(evt, evt.GetType());
                     }
 
-                    foreach (var modifiedKnownState in updateContext.ModifiedKnownStates)
-                    {
-                        changes.AddOrReplace(modifiedKnownState.Key, modifiedKnownState.Value);
-                    }
-
                     if (invoice.Status == "complete" ||
                        ((invoice.Status == "invalid" || invoice.Status == "expired") && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
                     {
@@ -158,39 +126,18 @@ namespace BTCPayServer.HostedServices
             }
 
             var derivationStrategies = invoice.GetDerivationStrategies(_NetworkProvider).ToArray();
-            var payments = await GetPaymentsWithTransaction(derivationStrategies, invoice);
-            foreach (Task<NetworkCoins> coinsAsync in GetCoinsPerNetwork(context, invoice, derivationStrategies))
+            var payments = invoice.GetPayments().Where(p => p.Accounted).ToArray();
+            foreach (BTCPayNetwork network in _NetworkProvider.GetAll())
             {
-                var coins = await coinsAsync;
-                if (coins.TimestampedCoins.Length == 0)
-                    continue;
-                bool dirtyAddress = false;
-                if (coins.State != null)
-                    context.ModifiedKnownStates.AddOrReplace(coins.Wallet.Network, coins.State);
-                var alreadyAccounted = new HashSet<OutPoint>(invoice.GetPayments(coins.Wallet.Network).Select(p => p.Outpoint));
-
-                foreach (var coin in coins.TimestampedCoins.Where(c => !alreadyAccounted.Contains(c.Coin.Outpoint)))
-                {
-                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.DateTime, coin.Coin, coins.Wallet.Network.CryptoCode).ConfigureAwait(false);
-#pragma warning disable CS0618
-                    invoice.Payments.Add(payment);
-#pragma warning restore CS0618
-                    alreadyAccounted.Add(coin.Coin.Outpoint);
-                    context.Events.Add(new InvoiceEvent(invoice, 1002, "invoice_receivedPayment"));
-                    dirtyAddress = true;
-                }
-                if (dirtyAddress)
-                {
-                    payments = await GetPaymentsWithTransaction(derivationStrategies, invoice);
-                }
-                var network = coins.Wallet.Network;
                 var cryptoData = invoice.GetCryptoData(network, _NetworkProvider);
+                if (cryptoData == null) // Altcoin not supported
+                    continue;
                 var cryptoDataAll = invoice.GetCryptoData(_NetworkProvider);
                 var accounting = cryptoData.Calculate();
 
                 if (invoice.Status == "new" || invoice.Status == "expired")
                 {
-                    var totalPaid = payments.Select(p => p.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    var totalPaid = payments.Select(p => p.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
                     if (totalPaid >= accounting.TotalDue)
                     {
                         if (invoice.Status == "new")
@@ -213,32 +160,14 @@ namespace BTCPayServer.HostedServices
                     {
                         invoice.ExceptionStatus = "paidPartial";
                         context.MarkDirty();
-                        if (dirtyAddress)
-                        {
-                            var address = await coins.Wallet.ReserveAddressAsync(coins.Strategy);
-                            Logs.PayServer.LogInformation("Generate new " + address);
-                            await _InvoiceRepository.NewAddress(invoice.Id, address, network);
-                        }
                     }
                 }
 
                 if (invoice.Status == "paid")
                 {
-                    IEnumerable<AccountedPaymentEntity> transactions = payments;
-                    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 transactions = payments.Where(p => p.GetCryptoPaymentData().PaymentConfirmed(p, invoice.SpeedPolicy, network));           
 
-                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    var totalConfirmed = transactions.Select(t => t.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
 
                     if (// Is after the monitoring deadline
                        (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
@@ -262,9 +191,8 @@ namespace BTCPayServer.HostedServices
 
                 if (invoice.Status == "confirmed")
                 {
-                    IEnumerable<AccountedPaymentEntity> transactions = payments;
-                    transactions = transactions.Where(t => t.Confirmations >= 6);
-                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    var transactions = payments.Where(p => p.GetCryptoPaymentData().PaymentCompleted(p, network));
+                    var totalConfirmed = transactions.Select(t => t.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
                     if (totalConfirmed >= accounting.TotalDue)
                     {
                         context.Events.Add(new InvoiceEvent(invoice, 1006, "invoice_completed"));
@@ -275,127 +203,6 @@ namespace BTCPayServer.HostedServices
             }
         }
 
-        private IEnumerable<Task<NetworkCoins>> GetCoinsPerNetwork(UpdateInvoiceContext context, InvoiceEntity invoice, DerivationStrategy[] strategies)
-        {
-            return strategies
-                                .Select(d => (Wallet: _WalletProvider.IsAvailable(d.Network) ? _WalletProvider.GetWallet(d.Network) : null,
-                                              Network: d.Network,
-                                              Strategy: d.DerivationStrategyBase))
-                                .Where(d => d.Wallet != null)
-                                .Select(d => (Network: d.Network,
-                                              Coins: d.Wallet.GetCoins(d.Strategy, context.KnownStates.TryGet(d.Network))))
-                                .Select(async d =>
-                                {
-                                    var coins = await d.Coins;
-                                    // Keep only coins from the invoice
-                                    coins.TimestampedCoins = coins.TimestampedCoins.Where(c => invoice.AvailableAddressHashes.Contains(c.Coin.ScriptPubKey.Hash.ToString() + d.Network.CryptoCode)).ToArray();
-                                    return coins;
-                                })
-                                .ToArray();
-        }
-
-
-        private async Task<IEnumerable<AccountedPaymentEntity>> GetPaymentsWithTransaction(DerivationStrategy[] derivations, InvoiceEntity invoice)
-        {
-            List<PaymentEntity> updatedPaymentEntities = new List<PaymentEntity>();
-            List<AccountedPaymentEntity> accountedPayments = new List<AccountedPaymentEntity>();
-            foreach (var network in derivations.Select(d => d.Network))
-            {
-                var wallet = _WalletProvider.GetWallet(network);
-                if (wallet == null)
-                    continue;
-
-                var transactions = await wallet.GetTransactions(invoice.GetPayments(wallet.Network)
-                    .Select(t => t.Outpoint.Hash)
-                    .ToArray());
-                var conflicts = GetConflicts(transactions.Select(t => t.Value));
-                foreach (var payment in invoice.GetPayments(network))
-                {
-                    if (!transactions.TryGetValue(payment.Outpoint.Hash, out TransactionResult tx))
-                        continue;
-
-                    AccountedPaymentEntity accountedPayment = new AccountedPaymentEntity()
-                    {
-                        Confirmations = tx.Confirmations,
-                        Transaction = tx.Transaction,
-                        Payment = payment
-                    };
-                    var txId = accountedPayment.Transaction.GetHash();
-                    var txConflict = conflicts.GetConflict(txId);
-                    var accounted = txConflict == null || txConflict.IsWinner(txId);
-                    if (accounted != payment.Accounted)
-                    {
-                        updatedPaymentEntities.Add(payment);
-                        payment.Accounted = accounted;
-                    }
-
-                    if (accounted)
-                        accountedPayments.Add(accountedPayment);
-                }
-            }
-            await _InvoiceRepository.UpdatePayments(updatedPaymentEntities);
-            return accountedPayments;
-        }
-
-        class TransactionConflict
-        {
-            public Dictionary<uint256, TransactionResult> Transactions { get; set; } = new Dictionary<uint256, TransactionResult>();
-
-
-            uint256 _Winner;
-            public bool IsWinner(uint256 txId)
-            {
-                if (_Winner == null)
-                {
-                    var confirmed = Transactions.FirstOrDefault(t => t.Value.Confirmations >= 1);
-                    if (!confirmed.Equals(default(KeyValuePair<uint256, TransactionResult>)))
-                    {
-                        _Winner = confirmed.Key;
-                    }
-                    else
-                    {
-                        // Take the most recent (bitcoin node would not forward a conflict without a successfull RBF)
-                        _Winner = Transactions
-                                .OrderByDescending(t => t.Value.Timestamp)
-                                .First()
-                                .Key;
-                    }
-                }
-                return _Winner == txId;
-            }
-        }
-        class TransactionConflicts : List<TransactionConflict>
-        {
-            public TransactionConflicts(IEnumerable<TransactionConflict> collection) : base(collection)
-            {
-
-            }
-
-            public TransactionConflict GetConflict(uint256 txId)
-            {
-                return this.FirstOrDefault(c => c.Transactions.ContainsKey(txId));
-            }
-        }
-        private TransactionConflicts GetConflicts(IEnumerable<TransactionResult> transactions)
-        {
-            Dictionary<OutPoint, TransactionConflict> conflictsByOutpoint = new Dictionary<OutPoint, TransactionConflict>();
-            foreach (var tx in transactions)
-            {
-                var hash = tx.Transaction.GetHash();
-                foreach (var input in tx.Transaction.Inputs)
-                {
-                    TransactionConflict conflict = new TransactionConflict();
-                    if (!conflictsByOutpoint.TryAdd(input.PrevOut, conflict))
-                    {
-                        conflict = conflictsByOutpoint[input.PrevOut];
-                    }
-                    if (!conflict.Transactions.ContainsKey(hash))
-                        conflict.Transactions.Add(hash, tx);
-                }
-            }
-            return new TransactionConflicts(conflictsByOutpoint.Where(c => c.Value.Transactions.Count > 1).Select(c => c.Value));
-        }
-
         TimeSpan _PollInterval;
         public TimeSpan PollInterval
         {
@@ -409,11 +216,15 @@ namespace BTCPayServer.HostedServices
             }
         }
 
-        private async Task Watch(string invoiceId)
+        private void Watch(string invoiceId)
         {
             if (invoiceId == null)
                 throw new ArgumentNullException(nameof(invoiceId));
             _WatchRequests.Add(invoiceId);
+        }
+
+        private async Task Wait(string invoiceId)
+        {
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
             try
             {
@@ -421,62 +232,57 @@ namespace BTCPayServer.HostedServices
                 if (invoice.ExpirationTime > now)
                 {
                     await Task.Delay(invoice.ExpirationTime - now, _Cts.Token);
-                    _WatchRequests.Add(invoiceId);
                 }
+                _WatchRequests.Add(invoiceId);
+                now = DateTimeOffset.UtcNow;
+                if (invoice.MonitoringExpiration > now)
+                {
+                    await Task.Delay(invoice.MonitoringExpiration - now, _Cts.Token);
+                }
+                _WatchRequests.Add(invoiceId);
             }
             catch when (_Cts.IsCancellationRequested)
             { }
+
         }
 
         BlockingCollection<string> _WatchRequests = new BlockingCollection<string>(new ConcurrentQueue<string>());
 
-        Task _Poller;
         Task _Loop;
+        Task _WaitingInvoices;
         CancellationTokenSource _Cts;
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
             _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-
-            _Poller = StartPoller(_Cts.Token);
             _Loop = StartLoop(_Cts.Token);
+            _WaitingInvoices = WaitPendingInvoices();
 
-            leases.Add(_EventAggregator.Subscribe<Events.NewBlockEvent>(async b => { await NotifyBlock(); }));
-            leases.Add(_EventAggregator.Subscribe<Events.TxOutReceivedEvent>(async b => { await NotifyReceived(b.ScriptPubKey, b.Network); }));
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceNeedUpdateEvent>(async b =>
+            {
+                    Watch(b.InvoiceId);
+            }));
             leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
             {
                 if (b.Name == "invoice_created")
                 {
-                    await Watch(b.InvoiceId);
+                    Watch(b.InvoiceId);
+                    await Wait(b.InvoiceId);
+                }
+
+                if (b.Name == "invoice_receivedPayment")
+                {
+                    Watch(b.InvoiceId);
                 }
             }));
-
             return Task.CompletedTask;
         }
 
-
-        private async Task StartPoller(CancellationToken cancellation)
+        private async Task WaitPendingInvoices()
         {
-            try
-            {
-                while (!cancellation.IsCancellationRequested)
-                {
-                    try
-                    {
-                        foreach (var pending in await _InvoiceRepository.GetPendingInvoices())
-                        {
-                            _WatchRequests.Add(pending);
-                        }
-                        await Task.Delay(PollInterval, cancellation);
-                    }
-                    catch (Exception ex) when (!cancellation.IsCancellationRequested)
-                    {
-                        Logs.PayServer.LogError(ex, $"Unhandled exception in InvoiceWatcher poller");
-                        await Task.Delay(PollInterval, cancellation);
-                    }
-                }
-            }
-            catch when (cancellation.IsCancellationRequested) { }
+            await Task.WhenAll((await _InvoiceRepository.GetPendingInvoices())
+                .Select(id => Wait(id)).ToArray());
+            _WaitingInvoices = null;
         }
 
         async Task StartLoop(CancellationToken cancellation)
@@ -525,7 +331,8 @@ namespace BTCPayServer.HostedServices
         {
             leases.Dispose();
             _Cts.Cancel();
-            return Task.WhenAll(_Poller, _Loop);
+            var waitingPendingInvoices = _WaitingInvoices ?? Task.CompletedTask;
+            return Task.WhenAll(waitingPendingInvoices, _Loop);
         }
     }
 }

BTCPayServer/HostedServices/NBXplorerListener.cs

@@ -13,6 +13,9 @@ using System.Collections.Concurrent;
 using NBXplorer.DerivationStrategy;
 using BTCPayServer.Events;
 using BTCPayServer.Services;
+using BTCPayServer.Services.Wallets;
+using NBitcoin;
+using NBXplorer.Models;
 
 namespace BTCPayServer.HostedServices
 {
@@ -24,22 +27,19 @@ namespace BTCPayServer.HostedServices
         InvoiceRepository _InvoiceRepository;
         private TaskCompletionSource<bool> _RunningTask;
         private CancellationTokenSource _Cts;
-        NBXplorerDashboard _Dashboards;
-        TransactionCacheProvider _TxCache;
+        BTCPayWalletProvider _Wallets;
 
         public NBXplorerListener(ExplorerClientProvider explorerClients,
-                                NBXplorerDashboard dashboard,
-                                TransactionCacheProvider cacheProvider,
+                                BTCPayWalletProvider wallets,
                                 InvoiceRepository invoiceRepository,
                                 EventAggregator aggregator, IApplicationLifetime lifetime)
         {
             PollInterval = TimeSpan.FromMinutes(1.0);
-            _Dashboards = dashboard;
+            _Wallets = wallets;
             _InvoiceRepository = invoiceRepository;
             _ExplorerClients = explorerClients;
             _Aggregator = aggregator;
             _Lifetime = lifetime;
-            _TxCache = cacheProvider;
         }
 
         CompositeDisposable leases = new CompositeDisposable();
@@ -71,17 +71,21 @@ namespace BTCPayServer.HostedServices
             {
                 if (nbxplorerEvent.NewState == NBXplorerState.Ready)
                 {
-                    await Listen(nbxplorerEvent.Network);
+                    var wallet = _Wallets.GetWallet(nbxplorerEvent.Network);
+                    if (_Wallets.IsAvailable(wallet.Network))
+                    {
+                        await Listen(wallet);
+                    }
                 }
             }));
 
             _ListenPoller = new Timer(async s =>
             {
-                foreach (var nbxplorerState in _Dashboards.GetAll())
+                foreach (var wallet in _Wallets.GetWallets())
                 {
-                    if (nbxplorerState.Status != null && nbxplorerState.Status.IsFullySynched)
+                    if (_Wallets.IsAvailable(wallet.Network))
                     {
-                        await Listen(nbxplorerState.Network);
+                        await Listen(wallet);
                     }
                 }
             }, null, 0, (int)PollInterval.TotalMilliseconds);
@@ -107,8 +111,9 @@ namespace BTCPayServer.HostedServices
             return Task.CompletedTask;
         }
 
-        private async Task Listen(BTCPayNetwork network)
+        private async Task Listen(BTCPayWallet wallet)
         {
+            var network = wallet.Network;
             bool cleanup = false;
             try
             {
@@ -126,10 +131,16 @@ namespace BTCPayServer.HostedServices
                     return;
                 }
                 cleanup = true;
+
                 using (session)
                 {
                     await session.ListenNewBlockAsync(_Cts.Token).ConfigureAwait(false);
                     await session.ListenDerivationSchemesAsync((await GetStrategies(network)).ToArray(), _Cts.Token).ConfigureAwait(false);
+
+                    Logs.PayServer.LogInformation($"{network.CryptoCode}: if any pending invoice got paid while offline...");
+                    int paymentCount = await FindPaymentViaPolling(wallet, network);
+                    Logs.PayServer.LogInformation($"{network.CryptoCode}: {paymentCount} payments happened while offline");
+
                     Logs.PayServer.LogInformation($"Connected to WebSocket of NBXplorer ({network.CryptoCode})");
                     while (!_Cts.IsCancellationRequested)
                     {
@@ -137,18 +148,35 @@ namespace BTCPayServer.HostedServices
                         switch (newEvent)
                         {
                             case NBXplorer.Models.NewBlockEvent evt:
-                                _TxCache.GetTransactionCache(network).NewBlock(evt.Hash, evt.PreviousBlockHash);
+
+                                await Task.WhenAll((await _InvoiceRepository.GetPendingInvoices())
+                                    .Select(invoiceId => UpdatePaymentStates(wallet, invoiceId))
+                                    .ToArray());
                                 _Aggregator.Publish(new Events.NewBlockEvent() { CryptoCode = evt.CryptoCode });
                                 break;
                             case NBXplorer.Models.NewTransactionEvent evt:
-                                foreach (var txout in evt.Outputs)
+                                wallet.InvalidateCache(evt.DerivationStrategy);
+                                foreach (var output in evt.Outputs)
                                 {
-                                    _TxCache.GetTransactionCache(network).AddToCache(evt.TransactionData);
-                                    _Aggregator.Publish(new Events.TxOutReceivedEvent()
+                                    foreach (var txCoin in evt.TransactionData.Transaction.Outputs.AsCoins()
+                                                                                .Where(o => o.ScriptPubKey == output.ScriptPubKey)
+                                                                                .Select(o => output.Redeem == null ? o : o.ToScriptCoin(output.Redeem)))
                                     {
-                                        Network = network,
-                                        ScriptPubKey = txout.ScriptPubKey
-                                    });
+                                        var invoice = await _InvoiceRepository.GetInvoiceFromScriptPubKey(output.ScriptPubKey, network.CryptoCode);
+                                        if (invoice != null)
+                                        {
+                                            var payment = invoice.GetPayments().FirstOrDefault(p => p.Outpoint == txCoin.Outpoint);
+                                            if (payment == null)
+                                            {
+                                                payment = await _InvoiceRepository.AddPayment(invoice.Id, DateTimeOffset.UtcNow, txCoin, network.CryptoCode);
+                                                await ReceivedPayment(wallet, invoice.Id, payment, evt.DerivationStrategy);
+                                            }
+                                            else
+                                            {
+                                                await UpdatePaymentStates(wallet, invoice.Id);
+                                            }
+                                        }
+                                    }
                                 }
                                 break;
                             default:
@@ -177,6 +205,164 @@ namespace BTCPayServer.HostedServices
             }
         }
 
+        async Task<InvoiceEntity> UpdatePaymentStates(BTCPayWallet wallet, string invoiceId)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, false);
+            List<PaymentEntity> updatedPaymentEntities = new List<PaymentEntity>();
+            var transactions = await wallet.GetTransactions(invoice.GetPayments(wallet.Network)
+                    .Select(t => t.Outpoint.Hash)
+                    .ToArray());
+            var conflicts = GetConflicts(transactions.Select(t => t.Value));
+            foreach (var payment in invoice.GetPayments(wallet.Network))
+            {
+                if (!transactions.TryGetValue(payment.Outpoint.Hash, out TransactionResult tx))
+                    continue;
+                var txId = tx.Transaction.GetHash();
+                var txConflict = conflicts.GetConflict(txId);
+                var accounted = txConflict == null || txConflict.IsWinner(txId);
+
+                bool updated = false;
+                if (accounted != payment.Accounted)
+                {
+                    updated = true;
+                    payment.Accounted = accounted;
+                }
+
+                var bitcoinLike = payment.GetCryptoPaymentData() as BitcoinLikePaymentData;
+
+                // Legacy
+                if (bitcoinLike == null)
+                {
+#pragma warning disable CS0618 // Type or member is obsolete
+                    payment.CryptoPaymentDataType = "BTCLike";
+#pragma warning restore CS0618 // Type or member is obsolete
+                    bitcoinLike = new BitcoinLikePaymentData();
+                    bitcoinLike.ConfirmationCount = tx.Confirmations;
+                    bitcoinLike.RBF = tx.Transaction.RBF;
+                    payment.SetCryptoPaymentData(bitcoinLike);
+                    updated = true;
+                }
+
+                if (bitcoinLike.ConfirmationCount != tx.Confirmations)
+                {
+                    if(wallet.Network.MaxTrackedConfirmation >= bitcoinLike.ConfirmationCount)
+                    { 
+                        bitcoinLike.ConfirmationCount = tx.Confirmations;
+                        payment.SetCryptoPaymentData(bitcoinLike);
+                        updated = true;
+                    }
+                }
+
+                if (updated)
+                    updatedPaymentEntities.Add(payment);
+            }
+            await _InvoiceRepository.UpdatePayments(updatedPaymentEntities);
+            if (updatedPaymentEntities.Count != 0)
+                _Aggregator.Publish(new Events.InvoiceNeedUpdateEvent(invoice.Id));
+            return invoice;
+        }
+
+        class TransactionConflict
+        {
+            public Dictionary<uint256, TransactionResult> Transactions { get; set; } = new Dictionary<uint256, TransactionResult>();
+
+
+            uint256 _Winner;
+            public bool IsWinner(uint256 txId)
+            {
+                if (_Winner == null)
+                {
+                    var confirmed = Transactions.FirstOrDefault(t => t.Value.Confirmations >= 1);
+                    if (!confirmed.Equals(default(KeyValuePair<uint256, TransactionResult>)))
+                    {
+                        _Winner = confirmed.Key;
+                    }
+                    else
+                    {
+                        // Take the most recent (bitcoin node would not forward a conflict without a successfull RBF)
+                        _Winner = Transactions
+                                .OrderByDescending(t => t.Value.Timestamp)
+                                .First()
+                                .Key;
+                    }
+                }
+                return _Winner == txId;
+            }
+        }
+        class TransactionConflicts : List<TransactionConflict>
+        {
+            public TransactionConflicts(IEnumerable<TransactionConflict> collection) : base(collection)
+            {
+
+            }
+
+            public TransactionConflict GetConflict(uint256 txId)
+            {
+                return this.FirstOrDefault(c => c.Transactions.ContainsKey(txId));
+            }
+        }
+        private TransactionConflicts GetConflicts(IEnumerable<TransactionResult> transactions)
+        {
+            Dictionary<OutPoint, TransactionConflict> conflictsByOutpoint = new Dictionary<OutPoint, TransactionConflict>();
+            foreach (var tx in transactions)
+            {
+                var hash = tx.Transaction.GetHash();
+                foreach (var input in tx.Transaction.Inputs)
+                {
+                    TransactionConflict conflict = new TransactionConflict();
+                    if (!conflictsByOutpoint.TryAdd(input.PrevOut, conflict))
+                    {
+                        conflict = conflictsByOutpoint[input.PrevOut];
+                    }
+                    if (!conflict.Transactions.ContainsKey(hash))
+                        conflict.Transactions.Add(hash, tx);
+                }
+            }
+            return new TransactionConflicts(conflictsByOutpoint.Where(c => c.Value.Transactions.Count > 1).Select(c => c.Value));
+        }
+
+        private async Task<int> FindPaymentViaPolling(BTCPayWallet wallet, BTCPayNetwork network)
+        {
+            int totalPayment = 0;
+            var invoices = await _InvoiceRepository.GetPendingInvoices();
+            foreach (var invoiceId in invoices)
+            {
+                var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true);
+                var alreadyAccounted = new HashSet<OutPoint>(invoice.GetPayments(network).Select(p => p.Outpoint));
+                var strategy = invoice.GetDerivationStrategy(network);
+                if (strategy == null)
+                    continue;
+                var coins = (await wallet.GetUnspentCoins(strategy))
+                             .Where(c => invoice.AvailableAddressHashes.Contains(c.Coin.ScriptPubKey.Hash.ToString() + network.CryptoCode))
+                             .ToArray();
+                foreach (var coin in coins.Where(c => !alreadyAccounted.Contains(c.Coin.Outpoint)))
+                {
+                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.Timestamp, coin.Coin, network.CryptoCode).ConfigureAwait(false);
+                    alreadyAccounted.Add(coin.Coin.Outpoint);
+                    invoice = await ReceivedPayment(wallet, invoice.Id, payment, strategy);
+                    totalPayment++;
+                }
+            }
+            return totalPayment;
+        }
+
+        private async Task<InvoiceEntity> ReceivedPayment(BTCPayWallet wallet, string invoiceId, PaymentEntity payment, DerivationStrategyBase strategy)
+        {
+            var invoice = (await UpdatePaymentStates(wallet, invoiceId));
+            var cryptoData = invoice.GetCryptoData(wallet.Network, _ExplorerClients.NetworkProviders);
+            if (cryptoData.GetDepositAddress().ScriptPubKey == payment.GetScriptPubKey() && cryptoData.Calculate().Due > Money.Zero)
+            {
+                var address = await wallet.ReserveAddressAsync(strategy);
+                await _InvoiceRepository.NewAddress(invoiceId, address, wallet.Network);
+                _Aggregator.Publish(new InvoiceNewAddressEvent(invoiceId, address.ToString(), wallet.Network));
+                cryptoData.DepositAddress = address.ToString();
+                invoice.SetCryptoData(cryptoData);
+            }
+            wallet.InvalidateCache(strategy);
+            _Aggregator.Publish(new InvoiceEvent(invoiceId, 1002, "invoice_receivedPayment"));
+            return invoice;
+        }
+
         private async Task<List<DerivationStrategyBase>> GetStrategies(BTCPayNetwork network)
         {
             List<DerivationStrategyBase> strategies = new List<DerivationStrategyBase>();

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -193,6 +193,7 @@ namespace BTCPayServer.HostedServices
                 _Aggregator.Publish(new NBXplorerErrorEvent(_Network, error));
             }
 
+            _Dashboard.Publish(_Network, State, status, error);
             if (oldState != State)
             {
                 if (State == NBXplorerState.Synching)
@@ -205,7 +206,6 @@ namespace BTCPayServer.HostedServices
                 }
                 _Aggregator.Publish(new NBXplorerStateChangedEvent(_Network, oldState, State));
             }
-            _Dashboard.Publish(_Network, State, status, error);
             return oldState != State;
         }
 

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -142,8 +142,6 @@ namespace BTCPayServer.Hosting
                 BlockTarget = 20
             });
 
-            services.AddSingleton<TransactionCacheProvider>();
-
             services.AddSingleton<IHostedService, NBXplorerWaiters>();
             services.AddSingleton<IHostedService, NBXplorerListener>();
             services.AddSingleton<IHostedService, InvoiceNotificationManager>();

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -22,6 +22,7 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Routing;
 using Microsoft.AspNetCore.Http.Extensions;
 using BTCPayServer.Controllers;
+using System.Net.WebSockets;
 
 namespace BTCPayServer.Hosting
 {
@@ -82,6 +83,8 @@ namespace BTCPayServer.Hosting
             {
                 await _Next(httpContext);
             }
+            catch (WebSocketException)
+            { }
             catch (UnauthorizedAccessException ex)
             {
                 await HandleBitpayHttpException(httpContext, new BitpayHttpException(401, ex.Message));

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -1,12 +1,9 @@
 // <auto-generated />
 using BTCPayServer.Data;
-using BTCPayServer.Services.Invoices;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage;
-using Microsoft.EntityFrameworkCore.Storage.Internal;
 using System;
 
 namespace BTCPayServer.Migrations

BTCPayServer/Services/HardwareWalletService.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Wallets;
 using LedgerWallet;
 using NBitcoin;
 using NBXplorer.DerivationStrategy;
@@ -115,6 +116,8 @@ namespace BTCPayServer.Services
                 throw new ArgumentNullException(nameof(Network));
             if (strategy == null)
                 throw new ArgumentNullException(nameof(strategy));
+            if (!strategy.Segwit)
+                return false;
             return await GetKeyPath(_Ledger, network, strategy) != null;
         }
 
@@ -145,11 +148,11 @@ namespace BTCPayServer.Services
         }
 
         public async Task<Transaction> SendToAddress(DirectDerivationStrategy strategy, 
-                                                             Coin[] coins, BTCPayNetwork network, 
+                                                             ReceivedCoin[] coins, BTCPayNetwork network, 
                                                              (IDestination destination, Money amount, bool substractFees)[] send, 
                                                              FeeRate feeRate, 
                                                              IDestination changeAddress,
-                                                             Dictionary<Script, KeyPath> keypaths = null)
+                                                             KeyPath changeKeyPath)
         {
             if (strategy == null)
                 throw new ArgumentNullException(nameof(strategy));
@@ -159,8 +162,6 @@ namespace BTCPayServer.Services
                 throw new ArgumentNullException(nameof(feeRate));
             if (changeAddress == null)
                 throw new ArgumentNullException(nameof(changeAddress));
-            if (keypaths == null)
-                throw new ArgumentNullException(nameof(keypaths));
             if (feeRate.FeePerK <= Money.Zero)
             {
                 throw new ArgumentOutOfRangeException(nameof(feeRate), "The fee rate should be above zero");
@@ -184,7 +185,7 @@ namespace BTCPayServer.Services
             }
 
             TransactionBuilder builder = new TransactionBuilder();
-            builder.AddCoins(coins);
+            builder.AddCoins(coins.Select(c=>c.Coin).ToArray());
 
             foreach (var element in send)
             {
@@ -197,6 +198,12 @@ namespace BTCPayServer.Services
             builder.Shuffle();
             var unsigned = builder.BuildTransaction(false);
 
+            var keypaths = new Dictionary<Script, KeyPath>();
+            foreach(var c in coins)
+            {
+                keypaths.TryAdd(c.Coin.ScriptPubKey, c.KeyPath);
+            }
+
             var hasChange = unsigned.Outputs.Count == 2;
             var usedCoins = builder.FindSpentCoins(unsigned);
             _Transport.Timeout = TimeSpan.FromMinutes(5);
@@ -208,7 +215,7 @@ namespace BTCPayServer.Services
                     PubKey = strategy.Root.Derive(keypaths[c.TxOut.ScriptPubKey]).PubKey
                 }).ToArray(),
                 unsigned,
-                hasChange ? foundKeyPath.Derive(keypaths[changeAddress.ScriptPubKey]) : null);
+                hasChange ? foundKeyPath.Derive(changeKeyPath) : null);
             return fullySigned;
         }
     }

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -10,6 +10,7 @@ using NBitcoin.DataEncoders;
 using BTCPayServer.Data;
 using NBXplorer.Models;
 using NBXplorer;
+using NBXplorer.DerivationStrategy;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -167,6 +168,28 @@ namespace BTCPayServer.Services.Invoices
             set;
         }
 
+        public DerivationStrategyBase GetDerivationStrategy(BTCPayNetwork network)
+        {
+#pragma warning disable CS0618
+            JObject strategies = JObject.Parse(DerivationStrategies);
+#pragma warning restore CS0618
+            foreach (var strat in strategies.Properties())
+            {
+                if (strat.Name == network.CryptoCode)
+                {
+                    return BTCPayServer.DerivationStrategy.Parse(strat.Value.Value<string>(), network).DerivationStrategyBase;
+                }
+            }
+
+#pragma warning disable CS0618
+            if (network.IsBTC && !string.IsNullOrEmpty(DerivationStrategy))
+            {
+                return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, network).DerivationStrategyBase;
+            }
+            return null;
+#pragma warning restore CS0618
+        }
+
         public IEnumerable<DerivationStrategy> GetDerivationStrategies(BTCPayNetworkProvider networks)
         {
 #pragma warning disable CS0618
@@ -370,7 +393,7 @@ namespace BTCPayServer.Services.Invoices
                     dto.PaymentUrls = cryptoInfo.PaymentUrls;
                 }
 #pragma warning restore CS0618
-                if(!info.IsPhantomBTC)
+                if (!info.IsPhantomBTC)
                     dto.CryptoInfo.Add(cryptoInfo);
             }
 
@@ -512,6 +535,15 @@ namespace BTCPayServer.Services.Invoices
         [JsonProperty(PropertyName = "depositAddress")]
         public string DepositAddress { get; set; }
 
+        public BitcoinAddress GetDepositAddress()
+        {
+            if(string.IsNullOrEmpty(DepositAddress))
+            {
+                return null;
+            }
+            return BitcoinAddress.Create(DepositAddress, Network.NBitcoinNetwork);
+        }
+
         [JsonIgnore]
         public bool IsPhantomBTC { get; set; }
 
@@ -566,17 +598,6 @@ namespace BTCPayServer.Services.Invoices
 
     }
 
-    public class AccountedPaymentEntity
-    {
-        public int Confirmations
-        {
-            get;
-            set;
-        }
-        public PaymentEntity Payment { get; set; }
-        public Transaction Transaction { get; set; }
-    }
-
     public class PaymentEntity
     {
         public DateTimeOffset ReceivedTime
@@ -612,6 +633,41 @@ namespace BTCPayServer.Services.Invoices
             get;
             set;
         }
+
+        [Obsolete("Use GetCryptoPaymentData() instead")]
+        public string CryptoPaymentData { get; set; }
+        [Obsolete("Use GetCryptoPaymentData() instead")]
+        public string CryptoPaymentDataType { get; set; }
+
+        public CryptoPaymentData GetCryptoPaymentData()
+        {
+#pragma warning disable CS0618
+            if (string.IsNullOrEmpty(CryptoPaymentDataType))
+            {
+                return NullPaymentData.Instance;
+            }
+            if (CryptoPaymentDataType == "BTCLike")
+            {
+                return JsonConvert.DeserializeObject<BitcoinLikePaymentData>(CryptoPaymentData);
+            }
+            else
+                return NullPaymentData.Instance;
+#pragma warning restore CS0618
+        }
+
+        public void SetCryptoPaymentData(CryptoPaymentData cryptoPaymentData)
+        {
+#pragma warning disable CS0618
+            if (cryptoPaymentData is BitcoinLikePaymentData)
+            {
+                CryptoPaymentDataType = "BTCLike";
+            }
+            else
+                throw new NotSupportedException(cryptoPaymentData.ToString());
+            CryptoPaymentData = JsonConvert.SerializeObject(cryptoPaymentData);
+#pragma warning restore CS0618
+        }
+
         public Money GetValue()
         {
 #pragma warning disable CS0618
@@ -641,6 +697,62 @@ namespace BTCPayServer.Services.Invoices
             return CryptoCode ?? "BTC";
 #pragma warning restore CS0618
         }
+    }
+
+    public interface CryptoPaymentData
+    {
+        bool PaymentCompleted(PaymentEntity entity, BTCPayNetwork network);
+        bool PaymentConfirmed(PaymentEntity entity, SpeedPolicy speedPolicy, BTCPayNetwork network);
 
     }
+
+    public class NullPaymentData : CryptoPaymentData
+    {
+
+        private static readonly NullPaymentData _Instance = new NullPaymentData();
+        public static NullPaymentData Instance
+        {
+            get
+            {
+                return _Instance;
+            }
+        }
+        public bool PaymentCompleted(PaymentEntity entity, BTCPayNetwork network)
+        {
+            return false;
+        }
+
+        public bool PaymentConfirmed(PaymentEntity entity, SpeedPolicy speedPolicy, BTCPayNetwork network)
+        {
+            return false;
+        }
+    }
+
+    public class BitcoinLikePaymentData : CryptoPaymentData
+    {
+        public int ConfirmationCount { get; set; }
+        public bool RBF { get; set; }
+
+        public bool PaymentCompleted(PaymentEntity entity, BTCPayNetwork network)
+        {
+            return ConfirmationCount >= 6;
+        }
+
+        public bool PaymentConfirmed(PaymentEntity entity, SpeedPolicy speedPolicy, BTCPayNetwork network)
+        {
+            if (speedPolicy == SpeedPolicy.HighSpeed)
+            {
+                return ConfirmationCount >= 1 || !RBF;
+            }
+            else if (speedPolicy == SpeedPolicy.MediumSpeed)
+            {
+                return ConfirmationCount >= 1;
+            }
+            else if (speedPolicy == SpeedPolicy.LowSpeed)
+            {
+                return ConfirmationCount >= 6;
+            }
+            return false;
+        }
+    }
 }

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -58,12 +58,22 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        public async Task<string> GetInvoiceIdFromScriptPubKey(Script scriptPubKey, string cryptoCode)
+        public async Task<InvoiceEntity> GetInvoiceFromScriptPubKey(Script scriptPubKey, string cryptoCode)
         {
             using (var db = _ContextFactory.CreateContext())
             {
-                var result = await db.AddressInvoices.FindAsync(scriptPubKey.Hash.ToString() + "#" + cryptoCode);
-                return result?.InvoiceDataId;
+                var key = scriptPubKey.Hash.ToString() + "#" + cryptoCode;
+                var result = await db.AddressInvoices
+#pragma warning disable CS0618
+                                    .Where(a => a.Address == key)
+#pragma warning restore CS0618
+                                    .Select(a => a.InvoiceData)
+                                    .Include(a => a.Payments)
+                                    .Include(a => a.RefundAddresses)
+                                    .FirstOrDefaultAsync();
+                if (result == null)
+                    return null;
+                return ToEntity(result);
             }
         }
 
@@ -121,7 +131,7 @@ namespace BTCPayServer.Services.Invoices
                     {
                         InvoiceDataId = invoice.Id,
                         CreatedTime = DateTimeOffset.UtcNow,
-                    }.SetHash(BitcoinAddress.Create(cryptoData.DepositAddress, cryptoData.Network.NBitcoinNetwork).ScriptPubKey.Hash, cryptoData.CryptoCode));
+                    }.SetHash(cryptoData.GetDepositAddress().ScriptPubKey.Hash, cryptoData.CryptoCode));
                     context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
                     {
                         InvoiceDataId = invoice.Id,
@@ -444,14 +454,16 @@ namespace BTCPayServer.Services.Invoices
                     Output = receivedCoin.TxOut,
                     CryptoCode = cryptoCode,
 #pragma warning restore CS0618
-                    ReceivedTime = date.UtcDateTime
+                    ReceivedTime = date.UtcDateTime,
+                    Accounted = false
                 };
-
+                entity.SetCryptoPaymentData(new BitcoinLikePaymentData());
                 PaymentData data = new PaymentData
                 {
                     Id = receivedCoin.Outpoint.ToString(),
                     Blob = ToBytes(entity, null),
-                    InvoiceDataId = invoiceId
+                    InvoiceDataId = invoiceId,
+                    Accounted = false
                 };
 
                 context.Payments.Add(data);
@@ -473,8 +485,10 @@ namespace BTCPayServer.Services.Invoices
                     var data = new PaymentData();
                     data.Id = payment.Outpoint.ToString();
                     data.Accounted = payment.Accounted;
+                    data.Blob = ToBytes(payment, null);
                     context.Attach(data);
                     context.Entry(data).Property(o => o.Accounted).IsModified = true;
+                    context.Entry(data).Property(o => o.Blob).IsModified = true;
                 }
                 await context.SaveChangesAsync().ConfigureAwait(false);
             }

BTCPayServer/Services/TransactionCache.cs

@@ -1,96 +0,0 @@
-using System;
-using Microsoft.Extensions.Logging;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Options;
-using NBitcoin;
-using NBXplorer.Models;
-
-namespace BTCPayServer.Services
-{
-    public class TransactionCacheProvider
-    {
-        IOptions<MemoryCacheOptions> _Options;
-        public TransactionCacheProvider(IOptions<MemoryCacheOptions> options)
-        {
-            _Options = options;
-        }
-
-        ConcurrentDictionary<string, TransactionCache> _TransactionCaches = new ConcurrentDictionary<string, TransactionCache>();
-        public TransactionCache GetTransactionCache(BTCPayNetwork network)
-        {
-            if (network == null)
-                throw new ArgumentNullException(nameof(network));
-            return _TransactionCaches.GetOrAdd(network.CryptoCode, c => new TransactionCache(_Options, network));
-        }
-    }
-    public class TransactionCache : IDisposable
-    {
-        //IOptions<MemoryCacheOptions> _Options;
-        public TransactionCache(IOptions<MemoryCacheOptions> options, BTCPayNetwork network)
-        {
-            //if (network == null)
-            //    throw new ArgumentNullException(nameof(network));
-            //_Options = options;
-            //_MemoryCache = new MemoryCache(_Options);
-            //Network = network;
-        }
-
-        //uint256 _LastHash;
-        //int _ConfOffset;
-        //IMemoryCache _MemoryCache;
-        
-        public void NewBlock(uint256 newHash, uint256 previousHash)
-        {
-            //if (_LastHash != previousHash)
-            //{
-            //    var old = _MemoryCache;
-            //    _ConfOffset = 0;
-            //    _MemoryCache = new MemoryCache(_Options);
-            //    Thread.MemoryBarrier();
-            //    old.Dispose();
-            //}
-            //else
-            //    _ConfOffset++;
-            //_LastHash = newHash;
-        }
-
-        public TimeSpan CacheSpan { get; private set; } = TimeSpan.FromMinutes(60);
-
-        public BTCPayNetwork Network { get; private set; }
-
-        public void AddToCache(TransactionResult tx)
-        {
-            //Logging.Logs.PayServer.LogInformation($"ADD CACHE: {tx.Transaction.GetHash()} ({tx.Confirmations} conf)");
-            //_MemoryCache.Set(tx.Transaction.GetHash(), tx, DateTimeOffset.UtcNow + CacheSpan);
-        }
-
-
-        public TransactionResult GetTransaction(uint256 txId)
-        {
-            //var ok = _MemoryCache.TryGetValue(txId.ToString(), out object tx);
-            //Logging.Logs.PayServer.LogInformation($"GET CACHE: {txId} ({ok} plus {_ConfOffset})");
-
-            //var result = tx as TransactionResult;
-            //var confOffset = _ConfOffset;
-            //if (result != null && result.Confirmations > 0 && confOffset > 0)
-            //{
-            //    var serializer = new NBXplorer.Serializer(Network.NBitcoinNetwork);
-            //    result = serializer.ToObject<TransactionResult>(serializer.ToString(result));
-            //    result.Confirmations += confOffset;
-            //    result.Height += confOffset;
-            //}
-            //return result;
-            return null; // Does not work correctly yet
-        }
-
-        public void Dispose()
-        {
-            //_MemoryCache.Dispose();
-        }
-    }
-}

BTCPayServer/Services/Wallets/BTCPayWallet.cs

@@ -1,4 +1,5 @@
 using NBitcoin;
+using Microsoft.Extensions.Logging;
 using NBXplorer;
 using NBXplorer.DerivationStrategy;
 using System;
@@ -10,6 +11,8 @@ using BTCPayServer.Data;
 using System.Threading;
 using NBXplorer.Models;
 using Microsoft.Extensions.Caching.Memory;
+using BTCPayServer.Logging;
+using System.Collections.Concurrent;
 
 namespace BTCPayServer.Services.Wallets
 {
@@ -17,6 +20,13 @@ namespace BTCPayServer.Services.Wallets
     {
         public UTXOChanges PreviousCall { get; set; }
     }
+
+    public class ReceivedCoin
+    {
+        public Coin Coin { get; set; }
+        public DateTimeOffset Timestamp { get; set; }
+        public KeyPath KeyPath { get; set; }
+    }
     public class NetworkCoins
     {
         public class TimestampedCoin
@@ -25,21 +35,22 @@ namespace BTCPayServer.Services.Wallets
             public Coin Coin { get; set; }
         }
         public TimestampedCoin[] TimestampedCoins { get; set; }
-        public KnownState State { get; set; }
         public DerivationStrategyBase Strategy { get; set; }
         public BTCPayWallet Wallet { get; set; }
     }
     public class BTCPayWallet
     {
         private ExplorerClient _Client;
-        private TransactionCache _Cache;
-        public BTCPayWallet(ExplorerClient client, TransactionCache cache, BTCPayNetwork network)
+        private IMemoryCache _MemoryCache;
+        public BTCPayWallet(ExplorerClient client, IMemoryCache memoryCache, BTCPayNetwork network)
         {
             if (client == null)
                 throw new ArgumentNullException(nameof(client));
+            if (memoryCache == null)
+                throw new ArgumentNullException(nameof(memoryCache));
             _Client = client;
             _Network = network;
-            _Cache = cache;
+            _MemoryCache = memoryCache;
         }
 
 
@@ -52,7 +63,7 @@ namespace BTCPayServer.Services.Wallets
             }
         }
 
-        public TimeSpan CacheSpan { get; private set; } = TimeSpan.FromMinutes(60);
+        public TimeSpan CacheSpan { get; private set; } = TimeSpan.FromMinutes(5);
 
         public async Task<BitcoinAddress> ReserveAddressAsync(DerivationStrategyBase derivationStrategy)
         {
@@ -91,24 +102,57 @@ namespace BTCPayServer.Services.Wallets
         {
             if (txId == null)
                 throw new ArgumentNullException(nameof(txId));
-            var tx = _Cache.GetTransaction(txId);
-            if (tx != null)
-                return tx;
-            tx = await _Client.GetTransactionAsync(txId, cancellation);
-            _Cache.AddToCache(tx);
+            var tx = await _Client.GetTransactionAsync(txId, cancellation);
             return tx;
         }
 
-        public async Task<NetworkCoins> GetCoins(DerivationStrategyBase strategy, KnownState state, CancellationToken cancellation = default(CancellationToken))
+        public void InvalidateCache(DerivationStrategyBase strategy)
         {
-            var changes = await _Client.GetUTXOsAsync(strategy, state?.PreviousCall, false, cancellation).ConfigureAwait(false);
-            return new NetworkCoins()
+            _MemoryCache.Remove("CACHEDCOINS_" + strategy.ToString());
+            _FetchingUTXOs.TryRemove(strategy.ToString(), out var unused);
+        }
+        ConcurrentDictionary<string, TaskCompletionSource<UTXOChanges>> _FetchingUTXOs = new ConcurrentDictionary<string, TaskCompletionSource<UTXOChanges>>();
+
+        private async Task<UTXOChanges> GetUTXOChanges(DerivationStrategyBase strategy, CancellationToken cancellation)
+        {
+            var thisCompletionSource = new TaskCompletionSource<UTXOChanges>();
+            var completionSource = _FetchingUTXOs.GetOrAdd(strategy.ToString(), (s) => thisCompletionSource);
+            if (thisCompletionSource != completionSource)
+                return await completionSource.Task;
+            try
             {
-                TimestampedCoins = changes.Confirmed.UTXOs.Concat(changes.Unconfirmed.UTXOs).Select(c => new NetworkCoins.TimestampedCoin() { Coin = c.AsCoin(), DateTime = c.Timestamp }).ToArray(),
-                State = new KnownState() { PreviousCall = changes },
-                Strategy = strategy,
-                Wallet = this
-            };
+                var utxos = await _MemoryCache.GetOrCreateAsync("CACHEDCOINS_" + strategy.ToString(), async entry =>
+                {
+                    var now = DateTimeOffset.UtcNow;
+                    UTXOChanges result = null;
+                    try
+                    {
+                        result = await _Client.GetUTXOsAsync(strategy, null, false, cancellation).ConfigureAwait(false);
+                    }
+                    catch
+                    {
+                        Logs.PayServer.LogError("Call to NBXplorer GetUTXOsAsync timed out, this should never happen, please report this issue to NBXplorer developers");
+                        throw;
+                    }
+                    var spentTime = DateTimeOffset.UtcNow - now;
+                    if (spentTime.TotalSeconds > 30)
+                    {
+                        Logs.PayServer.LogWarning($"NBXplorer took {(int)spentTime.TotalSeconds} seconds to reply, there is something wrong, please report this issue to NBXplorer developers");
+                    }
+                    entry.AbsoluteExpiration = DateTimeOffset.UtcNow + CacheSpan;
+                    return result;
+                });
+                completionSource.TrySetResult(utxos);
+            }
+            catch (Exception ex)
+            {
+                completionSource.TrySetException(ex);
+            }
+            finally
+            {
+                _FetchingUTXOs.TryRemove(strategy.ToString(), out var unused);
+            }
+            return await completionSource.Task;
         }
 
         public Task<BroadcastResult[]> BroadcastTransactionsAsync(List<Transaction> transactions)
@@ -117,21 +161,26 @@ namespace BTCPayServer.Services.Wallets
             return Task.WhenAll(tasks);
         }
 
-        public async Task<(Coin[], Dictionary<Script, KeyPath>)> GetUnspentCoins(DerivationStrategyBase derivationStrategy, CancellationToken cancellation = default(CancellationToken))
+
+
+        public async Task<ReceivedCoin[]> GetUnspentCoins(DerivationStrategyBase derivationStrategy, CancellationToken cancellation = default(CancellationToken))
         {
-            var changes = await _Client.GetUTXOsAsync(derivationStrategy, null, false, cancellation).ConfigureAwait(false);
-            var keyPaths = new Dictionary<Script, KeyPath>();
-            foreach (var coin in changes.GetUnspentUTXOs())
-            {
-                keyPaths.TryAdd(coin.ScriptPubKey, coin.KeyPath);
-            }
-            return (changes.GetUnspentCoins(), keyPaths);
+            if (derivationStrategy == null)
+                throw new ArgumentNullException(nameof(derivationStrategy));
+            return (await GetUTXOChanges(derivationStrategy, cancellation))
+                          .GetUnspentUTXOs()
+                          .Select(c => new ReceivedCoin()
+                          {
+                              Coin = c.AsCoin(derivationStrategy),
+                              KeyPath = c.KeyPath,
+                              Timestamp = c.Timestamp
+                          }).ToArray();
         }
 
-        public async Task<Money> GetBalance(DerivationStrategyBase derivationStrategy)
+        public async Task<Money> GetBalance(DerivationStrategyBase derivationStrategy, CancellationToken cancellation = default(CancellationToken))
         {
-            var result = await _Client.GetUTXOsAsync(derivationStrategy, null, true);
-            return result.GetUnspentUTXOs().Select(c => c.Value).Sum();
+            UTXOChanges changes = await GetUTXOChanges(derivationStrategy, cancellation);
+            return changes.GetUnspentUTXOs().Select(c => c.Value).Sum();
         }
     }
 }

BTCPayServer/Services/Wallets/BTCPayWalletProvider.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 
 namespace BTCPayServer.Services.Wallets
 {
@@ -10,18 +11,28 @@ namespace BTCPayServer.Services.Wallets
     {
         private ExplorerClientProvider _Client;
         BTCPayNetworkProvider _NetworkProvider;
-        TransactionCacheProvider _TransactionCacheProvider;
+        IOptions<MemoryCacheOptions> _Options;
         public BTCPayWalletProvider(ExplorerClientProvider client,
-                                    TransactionCacheProvider transactionCacheProvider,
+                                    IOptions<MemoryCacheOptions> memoryCacheOption,
                                     BTCPayNetworkProvider networkProvider)
         {
             if (client == null)
                 throw new ArgumentNullException(nameof(client));
             _Client = client;
-            _TransactionCacheProvider = transactionCacheProvider;
             _NetworkProvider = networkProvider;
+            _Options = memoryCacheOption;
+
+            foreach(var network in networkProvider.GetAll())
+            {
+                var explorerClient = _Client.GetExplorerClient(network.CryptoCode);
+                if (explorerClient == null)
+                    continue;
+                _Wallets.Add(network.CryptoCode, new BTCPayWallet(explorerClient, new MemoryCache(_Options), network));
+            }
         }
 
+        Dictionary<string, BTCPayWallet> _Wallets = new Dictionary<string, BTCPayWallet>();
+
         public BTCPayWallet GetWallet(BTCPayNetwork network)
         {
             if (network == null)
@@ -32,16 +43,19 @@ namespace BTCPayServer.Services.Wallets
         {
             if (cryptoCode == null)
                 throw new ArgumentNullException(nameof(cryptoCode));
-            var network = _NetworkProvider.GetNetwork(cryptoCode);
-            var client = _Client.GetExplorerClient(cryptoCode);
-            if (network == null || client == null)
-                return null;
-            return new BTCPayWallet(client, _TransactionCacheProvider.GetTransactionCache(network), network);
+            _Wallets.TryGetValue(cryptoCode, out var result);
+            return result;
         }
 
         public bool IsAvailable(BTCPayNetwork network)
         {
             return _Client.IsAvailable(network);
         }
+
+        public IEnumerable<BTCPayWallet> GetWallets()
+        {
+            foreach (var w in _Wallets)
+                yield return w.Value;
+        }
     }
 }