Better timestamp for invoice logs, fix bugs which can happen if invoice get deleted

Viacoin: add to README

BTCPayServer.Tests/Lnd/UnitTests.cs

@@ -110,13 +110,14 @@ namespace BTCPayServer.Tests.Lnd
             var merchantInvoice = await InvoiceClient.CreateInvoice(10000, "Hello world", TimeSpan.FromSeconds(3600));
 
             await EnsureLightningChannelAsync();
-            var payResponse = await CustomerLnd.SendPaymentSyncAsync(new LnrpcSendRequest
-            {
-                Payment_request = merchantInvoice.BOLT11
-            });
 
             await EventuallyAsync(async () =>
             {
+                var payResponse = await CustomerLnd.SendPaymentSyncAsync(new LnrpcSendRequest
+                {
+                    Payment_request = merchantInvoice.BOLT11
+                });
+                
                 var invoice = await InvoiceClient.GetInvoice(merchantInvoice.Id);
                 Assert.True(invoice.PaidAt.HasValue);
             });

BTCPayServer.Tests/docker-compose.yml

@@ -63,7 +63,7 @@ services:
 
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.2.8
+    image: nicolasdorier/nbxplorer:1.0.2.14
     ports:
       - "32838:32838"
     expose: 

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-		<Version>1.0.2.55</Version>
+		<Version>1.0.2.62</Version>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <ItemGroup>
@@ -35,18 +35,18 @@
     <PackageReference Include="Hangfire" Version="1.6.19" />
     <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
     <PackageReference Include="Hangfire.PostgreSql" Version="1.4.8.2" />
-    <PackageReference Include="LedgerWallet" Version="1.0.1.36" />
+    <PackageReference Include="LedgerWallet" Version="2.0.0" />
     <PackageReference Include="Meziantou.AspNetCore.BundleTagHelpers" Version="2.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
     <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.0" />
-    <PackageReference Include="NBitcoin" Version="4.1.1.27" />
+    <PackageReference Include="NBitcoin" Version="4.1.1.32" />
     <PackageReference Include="NBitpayClient" Version="1.0.0.29" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.2.13" />
+    <PackageReference Include="NBXplorer.Client" Version="1.0.2.15" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
-    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.14" />
+    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.16" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.0" />
     <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />
     <PackageReference Include="Text.Analyzers" Version="2.6.0" />

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -74,23 +74,40 @@ namespace BTCPayServer.Configuration
                 setting.ExplorerUri = conf.GetOrDefault<Uri>($"{net.CryptoCode}.explorer.url", net.NBXplorerNetwork.DefaultSettings.DefaultUrl);
                 setting.CookieFile = conf.GetOrDefault<string>($"{net.CryptoCode}.explorer.cookiefile", net.NBXplorerNetwork.DefaultSettings.DefaultCookieFile);
                 NBXplorerConnectionSettings.Add(setting);
-                var lightning = conf.GetOrDefault<string>($"{net.CryptoCode}.lightning", string.Empty);
-                if(lightning.Length != 0)
                 {
-                    if(!LightningConnectionString.TryParse(lightning, true, out var connectionString, out var error))
+                    var lightning = conf.GetOrDefault<string>($"{net.CryptoCode}.lightning", string.Empty);
+                    if (lightning.Length != 0)
                     {
-                        throw new ConfigException($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
-                            $"If you have a lightning server use: 'type=clightning;server=/root/.lightning/lightning-rpc', " + Environment.NewLine +
-                            $"If you have a lightning charge server: 'type=charge;server=https://charge.example.com;api-token=yourapitoken'" + Environment.NewLine +
-                            $"If you have a lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
-                            $"              lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
-                            error);
+                        if (!LightningConnectionString.TryParse(lightning, true, out var connectionString, out var error))
+                        {
+                            throw new ConfigException($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
+                                $"If you have a lightning server use: 'type=clightning;server=/root/.lightning/lightning-rpc', " + Environment.NewLine +
+                                $"If you have a lightning charge server: 'type=charge;server=https://charge.example.com;api-token=yourapitoken'" + Environment.NewLine +
+                                $"If you have a lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                $"              lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                error);
+                        }
+                        if (connectionString.IsLegacy)
+                        {
+                            Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning will work but use an deprecated format, please replace it by '{connectionString.ToString()}'");
+                        }
+                        InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
                     }
-                    if(connectionString.IsLegacy)
+                }
+
+                {
+                    var lightning = conf.GetOrDefault<string>($"{net.CryptoCode}.external.lnd.grpc", string.Empty);
+                    if (lightning.Length != 0)
                     {
-                        Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning will work but use an deprecated format, please replace it by '{connectionString.ToString()}'");
+                        if (!LightningConnectionString.TryParse(lightning, false, out var connectionString, out var error))
+                        {
+                            throw new ConfigException($"Invalid setting {net.CryptoCode}.external.lnd.grpc, " + Environment.NewLine +
+                                $"lnd server: 'type=lnd-grpc;server=https://lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                $"lnd server: 'type=lnd-grpc;server=https://lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                error);
+                        }
+                        ExternalServicesByCryptoCode.Add(net.CryptoCode, new ExternalLNDGRPC(connectionString));
                     }
-                    InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
                 }
             }
 
@@ -104,11 +121,12 @@ namespace BTCPayServer.Configuration
             if (!RootPath.StartsWith("/", StringComparison.InvariantCultureIgnoreCase))
                 RootPath = "/" + RootPath;
             var old = conf.GetOrDefault<Uri>("internallightningnode", null);
-            if(old != null)
+            if (old != null)
                 throw new ConfigException($"internallightningnode should not be used anymore, use btclightning instead");
         }
         public string RootPath { get; set; }
         public Dictionary<string, LightningConnectionString> InternalLightningByCryptoCode { get; set; } = new Dictionary<string, LightningConnectionString>();
+        public ExternalServices ExternalServicesByCryptoCode { get; set; } = new ExternalServices();
 
         public BTCPayNetworkProvider NetworkProvider { get; set; }
         public string PostgresConnectionString
@@ -136,4 +154,29 @@ namespace BTCPayServer.Configuration
             return builder.ToString();
         }
     }
+    
+    public class ExternalServices : MultiValueDictionary<string, ExternalService>
+    {
+        public IEnumerable<T> GetServices<T>(string cryptoCode) where T : ExternalService
+        {
+            if (!this.TryGetValue(cryptoCode.ToUpperInvariant(), out var services))
+                return Array.Empty<T>();
+            return services.OfType<T>();
+        }
+    }
+
+    public class ExternalService
+    {
+
+    }
+
+    public class ExternalLNDGRPC : ExternalService
+    {
+        public ExternalLNDGRPC(LightningConnectionString connectionString)
+        {
+            ConnectionString = connectionString;
+        }
+
+        public LightningConnectionString ConnectionString { get; set; }
+    }
 }

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -40,6 +40,7 @@ namespace BTCPayServer.Configuration
                 app.Option($"--{crypto}explorerurl", $"URL of the NBXplorer for {network.CryptoCode} (default: {network.NBXplorerNetwork.DefaultSettings.DefaultUrl})", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}explorercookiefile", $"Path to the cookie file (default: {network.NBXplorerNetwork.DefaultSettings.DefaultCookieFile})", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}lightning", $"Easy configuration of lightning for the server administrator: Must be a UNIX socket of c-lightning (lightning-rpc) or URL to a charge server (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externallndgrpc", $"The LND gRPC configuration BTCPay will expose to easily connect to the internal lnd wallet from Zap wallet (default: empty)", CommandOptionType.SingleValue);
             }
             return app;
         }

BTCPayServer/Controllers/InvoiceController.cs

@@ -84,6 +84,8 @@ namespace BTCPayServer.Controllers
 
         internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl)
         {
+            InvoiceLogs logs = new InvoiceLogs();
+            logs.Write("Creation of invoice starting");
             var entity = new InvoiceEntity
             {
                 InvoiceTime = DateTimeOffset.UtcNow
@@ -136,6 +138,7 @@ namespace BTCPayServer.Controllers
             var rateRules = storeBlob.GetRateRules(_NetworkProvider);
             var fetchingByCurrencyPair = _RateProvider.FetchRates(currencyPairsToFetch, rateRules);
 
+            var fetchingAll = WhenAllFetched(logs, fetchingByCurrencyPair);
             var supportedPaymentMethods = store.GetSupportedPaymentMethods(_NetworkProvider)
                                                .Select(c =>
                                                 (Handler: (IPaymentMethodHandler)_ServiceProvider.GetService(typeof(IPaymentMethodHandler<>).MakeGenericType(c.GetType())),
@@ -144,59 +147,26 @@ namespace BTCPayServer.Controllers
                                                 .Where(c => c.Network != null)
                                                 .Select(o =>
                                                     (SupportedPaymentMethod: o.SupportedPaymentMethod,
-                                                    PaymentMethod: CreatePaymentMethodAsync(fetchingByCurrencyPair, o.Handler, o.SupportedPaymentMethod, o.Network, entity, store)))
+                                                    PaymentMethod: CreatePaymentMethodAsync(fetchingByCurrencyPair, o.Handler, o.SupportedPaymentMethod, o.Network, entity, store, logs)))
                                                 .ToList();
-
-            List<string> invoiceLogs = new List<string>();
             List<ISupportedPaymentMethod> supported = new List<ISupportedPaymentMethod>();
             var paymentMethods = new PaymentMethodDictionary();
-
-            foreach (var pair in fetchingByCurrencyPair)
-            {
-                var rateResult = await pair.Value;
-                invoiceLogs.Add($"{pair.Key}: The rating rule is {rateResult.Rule}");
-                invoiceLogs.Add($"{pair.Key}: The evaluated rating rule is {rateResult.EvaluatedRule}");
-                if (rateResult.Errors.Count != 0)
-                {
-                    var allRateRuleErrors = string.Join(", ", rateResult.Errors.ToArray());
-                    invoiceLogs.Add($"{pair.Key}: Rate rule error ({allRateRuleErrors})");
-                }
-                if (rateResult.ExchangeExceptions.Count != 0)
-                {
-                    foreach (var ex in rateResult.ExchangeExceptions)
-                    {
-                        invoiceLogs.Add($"{pair.Key}: Exception reaching exchange {ex.ExchangeName} ({ex.Exception.Message})");
-                    }
-                }
-            }
-
             foreach (var o in supportedPaymentMethods)
             {
-                try
-                {
-                    var paymentMethod = await o.PaymentMethod;
-                    if (paymentMethod == null)
-                        throw new PaymentMethodUnavailableException("Payment method unavailable");
-                    supported.Add(o.SupportedPaymentMethod);
-                    paymentMethods.Add(paymentMethod);
-                }
-                catch (PaymentMethodUnavailableException ex)
-                {
-                    invoiceLogs.Add($"{o.SupportedPaymentMethod.PaymentId.CryptoCode} ({o.SupportedPaymentMethod.PaymentId.PaymentType}): Payment method unavailable ({ex.Message})");
-                }
-                catch (Exception ex)
-                {
-                    invoiceLogs.Add($"{o.SupportedPaymentMethod.PaymentId.CryptoCode} ({o.SupportedPaymentMethod.PaymentId.PaymentType}): Unexpected exception ({ex.ToString()})");
-                }
+                var paymentMethod = await o.PaymentMethod;
+                if (paymentMethod == null)
+                    continue;
+                supported.Add(o.SupportedPaymentMethod);
+                paymentMethods.Add(paymentMethod);
             }
 
             if (supported.Count == 0)
             {
                 StringBuilder errors = new StringBuilder();
                 errors.AppendLine("No payment method available for this store");
-                foreach (var error in invoiceLogs)
+                foreach (var error in logs.ToList())
                 {
-                    errors.AppendLine(error);
+                    errors.AppendLine(error.ToString());
                 }
                 throw new BitpayHttpException(400, errors.ToString());
             }
@@ -204,71 +174,108 @@ namespace BTCPayServer.Controllers
             entity.SetSupportedPaymentMethods(supported);
             entity.SetPaymentMethods(paymentMethods);
             entity.PosData = invoice.PosData;
-            entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, invoiceLogs, _NetworkProvider);
-
+            entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, logs, _NetworkProvider);
+            await fetchingAll;
             _EventAggregator.Publish(new Events.InvoiceEvent(entity.EntityToDTO(_NetworkProvider), 1001, "invoice_created"));
             var resp = entity.EntityToDTO(_NetworkProvider);
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }
 
-        private async Task<PaymentMethod> CreatePaymentMethodAsync(Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreData store)
+        private Task WhenAllFetched(InvoiceLogs logs, Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair)
         {
-            var storeBlob = store.GetStoreBlob();
-            var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
-            if (rate.Value == null)
-                return null;
-            PaymentMethod paymentMethod = new PaymentMethod();
-            paymentMethod.ParentEntity = entity;
-            paymentMethod.Network = network;
-            paymentMethod.SetId(supportedPaymentMethod.PaymentId);
-            paymentMethod.Rate = rate.Value.Value;
-            var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network);
-            if (storeBlob.NetworkFeeDisabled)
-                paymentDetails.SetNoTxFee();
-            paymentMethod.SetPaymentMethodDetails(paymentDetails);
-
-            Func<Money, Money, bool> compare = null;
-            CurrencyValue limitValue = null;
-            string errorMessage = null;
-            if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.LightningLike &&
-               storeBlob.LightningMaxValue != null)
+            return Task.WhenAll(fetchingByCurrencyPair.Select(async pair =>
             {
-                compare = (a, b) => a > b;
-                limitValue = storeBlob.LightningMaxValue;
-                errorMessage = "The amount of the invoice is too high to be paid with lightning";
-            }
-            else if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.BTCLike &&
-               storeBlob.OnChainMinValue != null)
-            {
-                compare = (a, b) => a < b;
-                limitValue = storeBlob.OnChainMinValue;
-                errorMessage = "The amount of the invoice is too low to be paid on chain";
-            }
-
-            if (compare != null)
-            {
-                var limitValueRate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, limitValue.Currency)];
-                if (limitValueRate.Value.HasValue)
+                var rateResult = await pair.Value;
+                logs.Write($"{pair.Key}: The rating rule is {rateResult.Rule}");
+                logs.Write($"{pair.Key}: The evaluated rating rule is {rateResult.EvaluatedRule}");
+                if (rateResult.Errors.Count != 0)
                 {
-                    var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.Value.Value);
-                    if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
+                    var allRateRuleErrors = string.Join(", ", rateResult.Errors.ToArray());
+                    logs.Write($"{pair.Key}: Rate rule error ({allRateRuleErrors})");
+                }
+                if (rateResult.ExchangeExceptions.Count != 0)
+                {
+                    foreach (var ex in rateResult.ExchangeExceptions)
                     {
-                        throw new PaymentMethodUnavailableException(errorMessage);
+                        logs.Write($"{pair.Key}: Exception reaching exchange {ex.ExchangeName} ({ex.Exception.Message})");
                     }
                 }
-            }
-            ///////////////
+            }).ToArray());
+        }
+
+        private async Task<PaymentMethod> CreatePaymentMethodAsync(Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreData store, InvoiceLogs logs)
+        {
+            try
+            {
+                var storeBlob = store.GetStoreBlob();
+                var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
+                if (rate.Value == null)
+                {
+                    return null;
+                }
+                PaymentMethod paymentMethod = new PaymentMethod();
+                paymentMethod.ParentEntity = entity;
+                paymentMethod.Network = network;
+                paymentMethod.SetId(supportedPaymentMethod.PaymentId);
+                paymentMethod.Rate = rate.Value.Value;
+                var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network);
+                if (storeBlob.NetworkFeeDisabled)
+                    paymentDetails.SetNoTxFee();
+                paymentMethod.SetPaymentMethodDetails(paymentDetails);
+
+                Func<Money, Money, bool> compare = null;
+                CurrencyValue limitValue = null;
+                string errorMessage = null;
+                if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.LightningLike &&
+                   storeBlob.LightningMaxValue != null)
+                {
+                    compare = (a, b) => a > b;
+                    limitValue = storeBlob.LightningMaxValue;
+                    errorMessage = "The amount of the invoice is too high to be paid with lightning";
+                }
+                else if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.BTCLike &&
+                   storeBlob.OnChainMinValue != null)
+                {
+                    compare = (a, b) => a < b;
+                    limitValue = storeBlob.OnChainMinValue;
+                    errorMessage = "The amount of the invoice is too low to be paid on chain";
+                }
+
+                if (compare != null)
+                {
+                    var limitValueRate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, limitValue.Currency)];
+                    if (limitValueRate.Value.HasValue)
+                    {
+                        var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.Value.Value);
+                        if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
+                        {
+                            logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: {errorMessage}");
+                            return null;
+                        }
+                    }
+                }
+                ///////////////
 
 
 #pragma warning disable CS0618
-            if (paymentMethod.GetId().IsBTCOnChain)
-            {
-                entity.TxFee = paymentMethod.TxFee;
-                entity.Rate = paymentMethod.Rate;
-                entity.DepositAddress = paymentMethod.DepositAddress;
-            }
+                if (paymentMethod.GetId().IsBTCOnChain)
+                {
+                    entity.TxFee = paymentMethod.TxFee;
+                    entity.Rate = paymentMethod.Rate;
+                    entity.DepositAddress = paymentMethod.DepositAddress;
+                }
 #pragma warning restore CS0618
-            return paymentMethod;
+                return paymentMethod;
+            }
+            catch (PaymentMethodUnavailableException ex)
+            {
+                logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: Payment method unavailable ({ex.Message})");
+            }
+            catch (Exception ex)
+            {
+                logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: Unexpected exception ({ex.ToString()})");
+            }
+            return null;
         }
 
         private SpeedPolicy ParseSpeedPolicy(string transactionSpeed, SpeedPolicy defaultPolicy)

BTCPayServer/Controllers/ServerController.cs

@@ -1,4 +1,5 @@
 using BTCPayServer.Configuration;
+using Microsoft.Extensions.Logging;
 using BTCPayServer.HostedServices;
 using BTCPayServer.Models;
 using BTCPayServer.Models.ServerViewModels;
@@ -11,6 +12,7 @@ using BTCPayServer.Validations;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
+using NBitcoin;
 using NBitcoin.DataEncoders;
 using System;
 using System.Collections.Generic;
@@ -238,65 +240,31 @@ namespace BTCPayServer.Controllers
         public IActionResult Services()
         {
             var result = new ServicesViewModel();
-            foreach (var internalNode in _Options.InternalLightningByCryptoCode)
+            foreach (var cryptoCode in _Options.ExternalServicesByCryptoCode.Keys)
             {
-                //Only BTC can be supported because gRPC does not allow http path rewriting.
-                if (internalNode.Key == "BTC" && GetExternalLNDConnectionString(internalNode.Value) != null)
                 {
-                    result.LNDServices.Add(new ServicesViewModel.LNDServiceViewModel()
+                    int i = 0;
+                    foreach (var grpcService in _Options.ExternalServicesByCryptoCode.GetServices<ExternalLNDGRPC>(cryptoCode))
                     {
-                        Crypto = internalNode.Key,
-                        Type = "gRPC"
-                    });
+                        result.LNDServices.Add(new ServicesViewModel.LNDServiceViewModel()
+                        {
+                            Crypto = cryptoCode,
+                            Type = "gRPC",
+                            Index = i++,
+                        });
+                    }
                 }
             }
             return View(result);
         }
 
-        private LightningConnectionString GetExternalLNDConnectionString(LightningConnectionString value)
+        [Route("server/services/lnd-grpc/{cryptoCode}/{index}")]
+        public IActionResult LNDGRPCServices(string cryptoCode, int index, uint? nonce)
         {
-            if (value.ConnectionType != LightningConnectionType.LndREST)
-                return null;
-            var external = new LightningConnectionString();
-            external.ConnectionType = LightningConnectionType.LndREST;
-            external.BaseUri = _Options.ExternalUrl ?? value.BaseUri;
-            if (external.BaseUri.Scheme == "http" || value.AllowInsecure)
-            {
-                external.AllowInsecure = true;
-            }
-
-            try
-            {
-                if (value.MacaroonFilePath != null)
-                    external.Macaroon = System.IO.File.ReadAllBytes(value.MacaroonFilePath);
-            }
-            catch
-            {
-                return null;
-            }
-            if (value.Macaroon != null)
-                external.Macaroon = value.Macaroon;
-
-            // If external url is provided, then we don't care about cert thumbprint
-            // because we override it at the reverse proxy level with a trusted certificate
-            if (_Options.ExternalUrl == null)
-            {
-                if (value.CertificateThumbprint != null)
-                {
-                    external.CertificateThumbprint = value.CertificateThumbprint;
-                    external.AllowInsecure = false;
-                }
-            }
-            return external;
-        }
-
-        [Route("server/services/lnd-grpc/{cryptoCode}")]
-        public IActionResult LNDGRPCServices(string cryptoCode, ulong? secret)
-        {
-            if (!_Options.InternalLightningByCryptoCode.TryGetValue(cryptoCode.ToUpperInvariant(), out var connectionString))
+            var external = GetExternalLNDConnectionString(cryptoCode, index);
+            if (external == null)
                 return NotFound();
             var model = new LNDGRPCServicesViewModel();
-            var external = GetExternalLNDConnectionString(connectionString);
 
             model.Host = $"{external.BaseUri.DnsSafeHost}:{external.BaseUri.Port}";
             model.SSL = external.BaseUri.Scheme == "https";
@@ -308,34 +276,43 @@ namespace BTCPayServer.Controllers
             {
                 model.Macaroon = Encoders.Hex.EncodeData(external.Macaroon);
             }
-            if (secret != null)
+
+            if (nonce != null)
             {
-                var lnConfig = _LnConfigProvider.GetConfig(secret.Value);
+                var configKey = GetConfigKey("lnd-grpc", cryptoCode, index, nonce.Value);
+                var lnConfig = _LnConfigProvider.GetConfig(configKey);
                 if (lnConfig != null)
                 {
-                    model.QRCodeLink = $"{this.Request.GetAbsoluteRoot().WithTrailingSlash()}lnd-config/{secret.Value}/lnd.config";
+                    model.QRCodeLink = $"{this.Request.GetAbsoluteRoot().WithTrailingSlash()}lnd-config/{configKey}/lnd.config";
                     model.QRCode = $"config={model.QRCodeLink}";
                 }
             }
+
             return View(model);
         }
-        [Route("lnd-config/{secret}/lnd.config")]
-        [AllowAnonymous]
-        public IActionResult GetLNDConfig(ulong secret)
+
+        private static uint GetConfigKey(string type, string cryptoCode, int index, uint nonce)
         {
-            var conf = _LnConfigProvider.GetConfig(secret);
+            return (uint)HashCode.Combine(type, cryptoCode, index, nonce);
+        }
+
+        [Route("lnd-config/{configKey}/lnd.config")]
+        [AllowAnonymous]
+        public IActionResult GetLNDConfig(uint configKey)
+        {
+            var conf = _LnConfigProvider.GetConfig(configKey);
             if (conf == null)
                 return NotFound();
             return Json(conf);
         }
 
-        [Route("server/services/lnd-grpc/{cryptoCode}")]
+        [Route("server/services/lnd-grpc/{cryptoCode}/{index}")]
         [HttpPost]
-        public IActionResult LNDGRPCServicesPOST(string cryptoCode)
+        public IActionResult LNDGRPCServicesPOST(string cryptoCode, int index)
         {
-            if (!_Options.InternalLightningByCryptoCode.TryGetValue(cryptoCode.ToUpperInvariant(), out var connectionString))
+            var external = GetExternalLNDConnectionString(cryptoCode, index);
+            if (external == null)
                 return NotFound();
-            var external = GetExternalLNDConnectionString(connectionString);
             LightningConfigurations confs = new LightningConfigurations();
             LightningConfiguration conf = new LightningConfiguration();
             conf.Type = "grpc";
@@ -346,10 +323,35 @@ namespace BTCPayServer.Controllers
             conf.Macaroon = external.Macaroon == null ? null : Encoders.Hex.EncodeData(external.Macaroon);
             conf.CertificateThumbprint = external.CertificateThumbprint == null ? null : Encoders.Hex.EncodeData(external.CertificateThumbprint);
             confs.Configurations.Add(conf);
-            var secret = _LnConfigProvider.KeepConfig(confs);
-            return RedirectToAction(nameof(LNDGRPCServices), new { cryptoCode = cryptoCode, secret = secret });
+
+            var nonce = RandomUtils.GetUInt32();
+            var configKey = GetConfigKey("lnd-grpc", cryptoCode, index, nonce);
+            _LnConfigProvider.KeepConfig(configKey, confs);
+            return RedirectToAction(nameof(LNDGRPCServices), new { cryptoCode = cryptoCode, nonce = nonce });
         }
 
+        private LightningConnectionString GetExternalLNDConnectionString(string cryptoCode, int index)
+        {
+            var connectionString = _Options.ExternalServicesByCryptoCode.GetServices<ExternalLNDGRPC>(cryptoCode).Skip(index).Select(c => c.ConnectionString).FirstOrDefault();
+            if (connectionString == null)
+                return null;
+            connectionString = connectionString.Clone();
+            if(connectionString.MacaroonFilePath != null)
+            {
+                try
+                {
+                    connectionString.Macaroon = System.IO.File.ReadAllBytes(connectionString.MacaroonFilePath);
+                    connectionString.MacaroonFilePath = null;
+                }
+                catch
+                {
+                    Logging.Logs.Configuration.LogWarning($"{cryptoCode}: The macaroon file path of the external LND grpc config was not found ({connectionString.MacaroonFilePath})");
+                    return null;
+                }
+            }
+            return connectionString;
+        }
+        
         [Route("server/theme")]
         public async Task<IActionResult> Theme()
         {

BTCPayServer/Controllers/StoresController.BTCLike.cs

@@ -195,216 +195,221 @@ namespace BTCPayServer.Controllers
 
             var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
 
-            var hw = new HardwareWalletService(webSocket);
-            object result = null;
-            try
+            using (var normalOperationTimeout = new CancellationTokenSource())
+            using (var signTimeout = new CancellationTokenSource())
             {
-                BTCPayNetwork network = null;
-                if (cryptoCode != null)
+                normalOperationTimeout.CancelAfter(TimeSpan.FromMinutes(30));
+                var hw = new HardwareWalletService(webSocket);
+                object result = null;
+                try
                 {
-                    network = _NetworkProvider.GetNetwork(cryptoCode);
-                    if (network == null)
-                        throw new FormatException("Invalid value for crypto code");
-                }
-
-                BitcoinAddress destinationAddress = null;
-                if (destination != null)
-                {
-                    try
+                    BTCPayNetwork network = null;
+                    if (cryptoCode != null)
                     {
-                        destinationAddress = BitcoinAddress.Create(destination, network.NBitcoinNetwork);
-                    }
-                    catch { }
-                    if (destinationAddress == null)
-                        throw new FormatException("Invalid value for destination");
-                }
-
-                FeeRate feeRateValue = null;
-                if (feeRate != null)
-                {
-                    try
-                    {
-                        feeRateValue = new FeeRate(Money.Satoshis(int.Parse(feeRate, CultureInfo.InvariantCulture)), 1);
-                    }
-                    catch { }
-                    if (feeRateValue == null || feeRateValue.FeePerK <= Money.Zero)
-                        throw new FormatException("Invalid value for fee rate");
-                }
-
-                Money amountBTC = null;
-                if (amount != null)
-                {
-                    try
-                    {
-                        amountBTC = Money.Parse(amount);
-                    }
-                    catch { }
-                    if (amountBTC == null || amountBTC <= Money.Zero)
-                        throw new FormatException("Invalid value for amount");
-                }
-
-                bool subsctractFeesValue = false;
-                if (substractFees != null)
-                {
-                    try
-                    {
-                        subsctractFeesValue = bool.Parse(substractFees);
-                    }
-                    catch { throw new FormatException("Invalid value for subtract fees"); }
-                }
-                if (command == "test")
-                {
-                    result = await hw.Test();
-                }
-                if (command == "getxpub")
-                {
-                    var getxpubResult = await hw.GetExtPubKey(network, account);
-                    result = getxpubResult;
-                }
-                if (command == "getinfo")
-                {
-                    var strategy = GetDirectDerivationStrategy(store, network);
-                    var strategyBase = GetDerivationStrategy(store, network);
-                    if (strategy == null || await hw.GetKeyPath(network, strategy) == null)
-                    {
-                        throw new Exception($"This store is not configured to use this ledger");
+                        network = _NetworkProvider.GetNetwork(cryptoCode);
+                        if (network == null)
+                            throw new FormatException("Invalid value for crypto code");
                     }
 
-                    var feeProvider = _FeeRateProvider.CreateFeeProvider(network);
-                    var recommendedFees = feeProvider.GetFeeRateAsync();
-                    var balance = _WalletProvider.GetWallet(network).GetBalance(strategyBase);
-                    result = new GetInfoResult() { Balance = (double)(await balance).ToDecimal(MoneyUnit.BTC), RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi };
-                }
+                    BitcoinAddress destinationAddress = null;
+                    if (destination != null)
+                    {
+                        try
+                        {
+                            destinationAddress = BitcoinAddress.Create(destination, network.NBitcoinNetwork);
+                        }
+                        catch { }
+                        if (destinationAddress == null)
+                            throw new FormatException("Invalid value for destination");
+                    }
 
-                if (command == "sendtoaddress")
-                {
-                    if (!_Dashboard.IsFullySynched(network.CryptoCode, out var summary))
-                        throw new Exception($"{network.CryptoCode}: not started or fully synched");
-                    var strategy = GetDirectDerivationStrategy(store, network);
-                    var strategyBase = GetDerivationStrategy(store, network);
-                    var wallet = _WalletProvider.GetWallet(network);
-                    var change = wallet.GetChangeAddressAsync(strategyBase);
+                    FeeRate feeRateValue = null;
+                    if (feeRate != null)
+                    {
+                        try
+                        {
+                            feeRateValue = new FeeRate(Money.Satoshis(int.Parse(feeRate, CultureInfo.InvariantCulture)), 1);
+                        }
+                        catch { }
+                        if (feeRateValue == null || feeRateValue.FeePerK <= Money.Zero)
+                            throw new FormatException("Invalid value for fee rate");
+                    }
 
-                    var unspentCoins = await wallet.GetUnspentCoins(strategyBase);
-                    var changeAddress = await change;
-                    var send = new[] { (
+                    Money amountBTC = null;
+                    if (amount != null)
+                    {
+                        try
+                        {
+                            amountBTC = Money.Parse(amount);
+                        }
+                        catch { }
+                        if (amountBTC == null || amountBTC <= Money.Zero)
+                            throw new FormatException("Invalid value for amount");
+                    }
+
+                    bool subsctractFeesValue = false;
+                    if (substractFees != null)
+                    {
+                        try
+                        {
+                            subsctractFeesValue = bool.Parse(substractFees);
+                        }
+                        catch { throw new FormatException("Invalid value for subtract fees"); }
+                    }
+                    if (command == "test")
+                    {
+                        result = await hw.Test(normalOperationTimeout.Token);
+                    }
+                    if (command == "getxpub")
+                    {
+                        var getxpubResult = await hw.GetExtPubKey(network, account, normalOperationTimeout.Token);
+                        result = getxpubResult;
+                    }
+                    if (command == "getinfo")
+                    {
+                        var strategy = GetDirectDerivationStrategy(store, network);
+                        var strategyBase = GetDerivationStrategy(store, network);
+                        if (strategy == null || await hw.GetKeyPath(network, strategy, normalOperationTimeout.Token) == null)
+                        {
+                            throw new Exception($"This store is not configured to use this ledger");
+                        }
+
+                        var feeProvider = _FeeRateProvider.CreateFeeProvider(network);
+                        var recommendedFees = feeProvider.GetFeeRateAsync();
+                        var balance = _WalletProvider.GetWallet(network).GetBalance(strategyBase);
+                        result = new GetInfoResult() { Balance = (double)(await balance).ToDecimal(MoneyUnit.BTC), RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi };
+                    }
+
+                    if (command == "sendtoaddress")
+                    {
+                        if (!_Dashboard.IsFullySynched(network.CryptoCode, out var summary))
+                            throw new Exception($"{network.CryptoCode}: not started or fully synched");
+                        var strategy = GetDirectDerivationStrategy(store, network);
+                        var strategyBase = GetDerivationStrategy(store, network);
+                        var wallet = _WalletProvider.GetWallet(network);
+                        var change = wallet.GetChangeAddressAsync(strategyBase);
+
+                        var unspentCoins = await wallet.GetUnspentCoins(strategyBase);
+                        var changeAddress = await change;
+                        var send = new[] { (
                         destination: destinationAddress as IDestination,
                         amount: amountBTC,
                         substractFees: subsctractFeesValue) };
 
-                    foreach (var element in send)
-                    {
-                        if (element.destination == null)
-                            throw new ArgumentNullException(nameof(element.destination));
-                        if (element.amount == null)
-                            throw new ArgumentNullException(nameof(element.amount));
-                        if (element.amount <= Money.Zero)
-                            throw new ArgumentOutOfRangeException(nameof(element.amount), "The amount should be above zero");
-                    }
+                        foreach (var element in send)
+                        {
+                            if (element.destination == null)
+                                throw new ArgumentNullException(nameof(element.destination));
+                            if (element.amount == null)
+                                throw new ArgumentNullException(nameof(element.amount));
+                            if (element.amount <= Money.Zero)
+                                throw new ArgumentOutOfRangeException(nameof(element.amount), "The amount should be above zero");
+                        }
 
-                    var foundKeyPath = await hw.GetKeyPath(network, strategy);
-                    if (foundKeyPath == null)
-                    {
-                        throw new HardwareWalletException($"This store is not configured to use this ledger");
-                    }
+                        var foundKeyPath = await hw.GetKeyPath(network, strategy, normalOperationTimeout.Token);
+                        if (foundKeyPath == null)
+                        {
+                            throw new HardwareWalletException($"This store is not configured to use this ledger");
+                        }
 
-                    TransactionBuilder builder = new TransactionBuilder();
-                    builder.StandardTransactionPolicy.MinRelayTxFee = summary.Status.BitcoinStatus.MinRelayTxFee;
-                    builder.SetConsensusFactory(network.NBitcoinNetwork);
-                    builder.AddCoins(unspentCoins.Select(c => c.Coin).ToArray());
+                        TransactionBuilder builder = new TransactionBuilder();
+                        builder.StandardTransactionPolicy.MinRelayTxFee = summary.Status.BitcoinStatus.MinRelayTxFee;
+                        builder.SetConsensusFactory(network.NBitcoinNetwork);
+                        builder.AddCoins(unspentCoins.Select(c => c.Coin).ToArray());
 
-                    foreach (var element in send)
-                    {
-                        builder.Send(element.destination, element.amount);
-                        if (element.substractFees)
-                            builder.SubtractFees();
-                    }
-                    builder.SetChange(changeAddress.Item1);
+                        foreach (var element in send)
+                        {
+                            builder.Send(element.destination, element.amount);
+                            if (element.substractFees)
+                                builder.SubtractFees();
+                        }
+                        builder.SetChange(changeAddress.Item1);
 
-                    if (network.MinFee == null)
-                    {
-                        builder.SendEstimatedFees(feeRateValue);
-                    }
-                    else
-                    {
-                        var estimatedFee = builder.EstimateFees(feeRateValue);
-                        if (network.MinFee > estimatedFee)
-                            builder.SendFees(network.MinFee);
-                        else
+                        if (network.MinFee == null)
+                        {
                             builder.SendEstimatedFees(feeRateValue);
-                    }
-                    builder.Shuffle();
-                    var unsigned = builder.BuildTransaction(false);
-
-                    var keypaths = new Dictionary<Script, KeyPath>();
-                    foreach (var c in unspentCoins)
-                    {
-                        keypaths.TryAdd(c.Coin.ScriptPubKey, c.KeyPath);
-                    }
-
-                    var hasChange = unsigned.Outputs.Count == 2;
-                    var usedCoins = builder.FindSpentCoins(unsigned);
-
-                    Dictionary<uint256, Transaction> parentTransactions = new Dictionary<uint256, Transaction>();
-
-                    if (!strategy.Segwit)
-                    {
-                        var parentHashes = usedCoins.Select(c => c.Outpoint.Hash).ToHashSet();
-                        var explorer = _ExplorerProvider.GetExplorerClient(network);
-                        var getTransactionAsyncs = parentHashes.Select(h => (Op: explorer.GetTransactionAsync(h), Hash: h)).ToList();
-                        foreach (var getTransactionAsync in getTransactionAsyncs)
-                        {
-                            var tx = (await getTransactionAsync.Op);
-                            if (tx == null)
-                                throw new Exception($"Parent transaction {getTransactionAsync.Hash} not found");
-                            parentTransactions.Add(tx.Transaction.GetHash(), tx.Transaction);
                         }
-                    }
-
-                    var transaction = await hw.SignTransactionAsync(usedCoins.Select(c => new SignatureRequest
-                    {
-                        InputTransaction = parentTransactions.TryGet(c.Outpoint.Hash),
-                        InputCoin = c,
-                        KeyPath = foundKeyPath.Derive(keypaths[c.TxOut.ScriptPubKey]),
-                        PubKey = strategy.Root.Derive(keypaths[c.TxOut.ScriptPubKey]).PubKey
-                    }).ToArray(), unsigned, hasChange ? foundKeyPath.Derive(changeAddress.Item2) : null);
-
-                    try
-                    {
-                        var broadcastResult = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { transaction });
-                        if (!broadcastResult[0].Success)
+                        else
                         {
-                            throw new Exception($"RPC Error while broadcasting: {broadcastResult[0].RPCCode} {broadcastResult[0].RPCCodeMessage} {broadcastResult[0].RPCMessage}");
+                            var estimatedFee = builder.EstimateFees(feeRateValue);
+                            if (network.MinFee > estimatedFee)
+                                builder.SendFees(network.MinFee);
+                            else
+                                builder.SendEstimatedFees(feeRateValue);
                         }
+                        builder.Shuffle();
+                        var unsigned = builder.BuildTransaction(false);
+
+                        var keypaths = new Dictionary<Script, KeyPath>();
+                        foreach (var c in unspentCoins)
+                        {
+                            keypaths.TryAdd(c.Coin.ScriptPubKey, c.KeyPath);
+                        }
+
+                        var hasChange = unsigned.Outputs.Count == 2;
+                        var usedCoins = builder.FindSpentCoins(unsigned);
+
+                        Dictionary<uint256, Transaction> parentTransactions = new Dictionary<uint256, Transaction>();
+
+                        if (!strategy.Segwit)
+                        {
+                            var parentHashes = usedCoins.Select(c => c.Outpoint.Hash).ToHashSet();
+                            var explorer = _ExplorerProvider.GetExplorerClient(network);
+                            var getTransactionAsyncs = parentHashes.Select(h => (Op: explorer.GetTransactionAsync(h), Hash: h)).ToList();
+                            foreach (var getTransactionAsync in getTransactionAsyncs)
+                            {
+                                var tx = (await getTransactionAsync.Op);
+                                if (tx == null)
+                                    throw new Exception($"Parent transaction {getTransactionAsync.Hash} not found");
+                                parentTransactions.Add(tx.Transaction.GetHash(), tx.Transaction);
+                            }
+                        }
+
+
+                        signTimeout.CancelAfter(TimeSpan.FromMinutes(5));
+                        var transaction = await hw.SignTransactionAsync(usedCoins.Select(c => new SignatureRequest
+                        {
+                            InputTransaction = parentTransactions.TryGet(c.Outpoint.Hash),
+                            InputCoin = c,
+                            KeyPath = foundKeyPath.Derive(keypaths[c.TxOut.ScriptPubKey]),
+                            PubKey = strategy.Root.Derive(keypaths[c.TxOut.ScriptPubKey]).PubKey
+                        }).ToArray(), unsigned, hasChange ? foundKeyPath.Derive(changeAddress.Item2) : null, signTimeout.Token);
+                        try
+                        {
+                            var broadcastResult = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { transaction });
+                            if (!broadcastResult[0].Success)
+                            {
+                                throw new Exception($"RPC Error while broadcasting: {broadcastResult[0].RPCCode} {broadcastResult[0].RPCCodeMessage} {broadcastResult[0].RPCMessage}");
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            throw new Exception("Error while broadcasting: " + ex.Message);
+                        }
+                        wallet.InvalidateCache(strategyBase);
+                        result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
                     }
-                    catch (Exception ex)
-                    {
-                        throw new Exception("Error while broadcasting: " + ex.Message);
-                    }
-                    wallet.InvalidateCache(strategyBase);
-                    result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
                 }
-            }
-            catch (OperationCanceledException)
-            { result = new LedgerTestResult() { Success = false, Error = "Timeout" }; }
-            catch (Exception ex)
-            { result = new LedgerTestResult() { Success = false, Error = ex.Message }; }
-            finally { hw.Dispose(); }
-            try
-            {
-                if (result != null)
+                catch (OperationCanceledException)
+                { result = new LedgerTestResult() { Success = false, Error = "Timeout" }; }
+                catch (Exception ex)
+                { result = new LedgerTestResult() { Success = false, Error = ex.Message }; }
+                finally { hw.Dispose(); }
+                try
                 {
-                    UTF8Encoding UTF8NOBOM = new UTF8Encoding(false);
-                    var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, _MvcJsonOptions.SerializerSettings));
-                    await webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, new CancellationTokenSource(2000).Token);
+                    if (result != null)
+                    {
+                        UTF8Encoding UTF8NOBOM = new UTF8Encoding(false);
+                        var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, _MvcJsonOptions.SerializerSettings));
+                        await webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, new CancellationTokenSource(2000).Token);
+                    }
+                }
+                catch { }
+                finally
+                {
+                    await webSocket.CloseSocket();
                 }
             }
-            catch { }
-            finally
-            {
-                await webSocket.CloseSocket();
-            }
-
             return new EmptyResult();
         }
 

BTCPayServer/Controllers/StoresController.LightningLike.cs

@@ -81,6 +81,12 @@ namespace BTCPayServer.Controllers
                     return View(vm);
                 }
 
+                if(connectionString.ConnectionType == LightningConnectionType.LndGRPC)
+                {
+                    ModelState.AddModelError(nameof(vm.ConnectionString), $"BTCPay does not support gRPC connections");
+                    return View(vm);
+                }
+
                 var internalDomain = internalLightning?.BaseUri?.DnsSafeHost;
 
                 bool isInternalNode = connectionString.ConnectionType == LightningConnectionType.CLightning ||

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -309,6 +309,8 @@ namespace BTCPayServer.HostedServices
             leases.Add(_EventAggregator.Subscribe<InvoiceEvent>(async e =>
             {
                 var invoice = await _InvoiceRepository.GetInvoice(null, e.Invoice.Id);
+                if (invoice == null)
+                    return;
                 List<Task> tasks = new List<Task>();
 
                 // Awaiting this later help make sure invoices should arrive in order

BTCPayServer/Logging/InvoiceLog.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Logging
+{
+    public class InvoiceLog
+    {
+        public DateTimeOffset Timestamp { get; set; }
+        public string Log { get; set; }
+
+        public override string ToString()
+        {
+            return $"{Timestamp.UtcDateTime}: {Log}";
+        }
+    }
+    public class InvoiceLogs
+    {
+        List<InvoiceLog> _InvoiceLogs = new List<InvoiceLog>();
+        public void Write(string data)
+        {
+            lock (_InvoiceLogs)
+            {
+                _InvoiceLogs.Add(new InvoiceLog() { Timestamp = DateTimeOffset.UtcNow, Log = data });
+            }
+        }
+
+        public List<InvoiceLog> ToList()
+        {
+            lock (_InvoiceLogs)
+            {
+                return _InvoiceLogs.ToList();
+            }
+        }
+    }
+}

BTCPayServer/Models/ServerViewModels/ServicesViewModel.cs

@@ -11,6 +11,7 @@ namespace BTCPayServer.Models.ServerViewModels
         {
             public string Crypto { get; set; }
             public string Type { get; set; }
+            public int Index { get; set; }
         }
         public List<LNDServiceViewModel> LNDServices { get; set; } = new List<LNDServiceViewModel>();
     }

BTCPayServer/Payments/Lightning/LightningConnectionString.cs

@@ -15,7 +15,8 @@ namespace BTCPayServer.Payments.Lightning
     {
         Charge,
         CLightning,
-        LndREST
+        LndREST,
+        LndGRPC
     }
     public class LightningConnectionString
     {
@@ -27,6 +28,7 @@ namespace BTCPayServer.Payments.Lightning
             typeMapping.Add("clightning", LightningConnectionType.CLightning);
             typeMapping.Add("charge", LightningConnectionType.Charge);
             typeMapping.Add("lnd-rest", LightningConnectionType.LndREST);
+            typeMapping.Add("lnd-grpc", LightningConnectionType.LndGRPC);
             typeMappingReverse = new Dictionary<LightningConnectionType, string>();
             foreach (var kv in typeMapping)
             {
@@ -161,6 +163,7 @@ namespace BTCPayServer.Payments.Lightning
                     }
                     break;
                 case LightningConnectionType.LndREST:
+                case LightningConnectionType.LndGRPC:
                     {
                         var server = Take(keyValues, "server");
                         if (server == null)
@@ -199,12 +202,12 @@ namespace BTCPayServer.Payments.Lightning
                         var macaroonFilePath = Take(keyValues, "macaroonfilepath");
                         if (macaroonFilePath != null)
                         {
-                            if(macaroon != null)
+                            if (macaroon != null)
                             {
                                 error = $"The key 'macaroon' is already specified";
                                 return false;
                             }
-                            if(!macaroonFilePath.EndsWith(".macaroon", StringComparison.OrdinalIgnoreCase))
+                            if (!macaroonFilePath.EndsWith(".macaroon", StringComparison.OrdinalIgnoreCase))
                             {
                                 error = $"The key 'macaroonfilepath' should point to a .macaroon file";
                                 return false;
@@ -274,6 +277,13 @@ namespace BTCPayServer.Payments.Lightning
             connectionString = result;
             return true;
         }
+
+        public LightningConnectionString Clone()
+        {
+            LightningConnectionString.TryParse(this.ToString(), false, out var result);
+            return result;
+        }
+
         private static string Take(Dictionary<string, string> keyValues, string key)
         {
             if (keyValues.TryGetValue(key, out var v))
@@ -393,6 +403,7 @@ namespace BTCPayServer.Payments.Lightning
                     builder.Append($";server={BaseUri}");
                     break;
                 case LightningConnectionType.LndREST:
+                case LightningConnectionType.LndGRPC:
                     if (Username == null)
                     {
                         builder.Append($";server={BaseUri}");

BTCPayServer/Properties/launchSettings.json

@@ -9,8 +9,8 @@
             "BTCPAY_BTCEXPLORERURL": "http://127.0.0.1:32838/",
             "ASPNETCORE_ENVIRONMENT": "Development",
             "BTCPAY_CHAINS": "btc,ltc",
-            "BTCPAY_BTCLIGHTNING": "http://api-token:foiewnccewuify@127.0.0.1:54938/",
-            //"BTCPAY_BTCLIGHTNING": "type=lnd-rest;server=https://lnd:lnd@127.0.0.1:53280/;allowinsecure=true",
+            "BTCPAY_BTCLIGHTNING": "type=charge;server=http://127.0.0.1:54938/;api-token=foiewnccewuify",
+            "BTCPAY_BTCEXTERNALLNDGRPC": "type=lnd-grpc;server=https://lnd:lnd@127.0.0.1:53280/;allowinsecure=true",
             "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver",
             "BTCPAY_BUNDLEJSCSS": "false"
         },

BTCPayServer/Services/HardwareWalletService.cs

@@ -34,26 +34,22 @@ namespace BTCPayServer.Services
             }
 
             SemaphoreSlim _Semaphore = new SemaphoreSlim(1, 1);
-            public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(10);
-            public async Task<byte[][]> Exchange(byte[][] apdus)
+            public async Task<byte[][]> Exchange(byte[][] apdus, CancellationToken cancellationToken)
             {
                 await _Semaphore.WaitAsync();
                 List<byte[]> responses = new List<byte[]>();
                 try
                 {
-                    using (CancellationTokenSource cts = new CancellationTokenSource(Timeout))
+                    foreach (var apdu in apdus)
                     {
-                        foreach (var apdu in apdus)
-                        {
-                            await this.webSocket.SendAsync(new ArraySegment<byte>(apdu), WebSocketMessageType.Binary, true, cts.Token);
-                        }
-                        foreach (var apdu in apdus)
-                        {
-                            byte[] response = new byte[300];
-                            var result = await this.webSocket.ReceiveAsync(new ArraySegment<byte>(response), cts.Token);
-                            Array.Resize(ref response, result.Count);
-                            responses.Add(response);
-                        }
+                        await this.webSocket.SendAsync(new ArraySegment<byte>(apdu), WebSocketMessageType.Binary, true, cancellationToken);
+                    }
+                    foreach (var apdu in apdus)
+                    {
+                        byte[] response = new byte[300];
+                        var result = await this.webSocket.ReceiveAsync(new ArraySegment<byte>(response), cancellationToken);
+                        Array.Resize(ref response, result.Count);
+                        responses.Add(response);
                     }
                 }
                 finally
@@ -86,20 +82,20 @@ namespace BTCPayServer.Services
             _Ledger = new LedgerClient(_Transport);
         }
 
-        public async Task<LedgerTestResult> Test()
+        public async Task<LedgerTestResult> Test(CancellationToken cancellation)
         {
-            var version = await _Ledger.GetFirmwareVersionAsync();
+            var version = await Ledger.GetFirmwareVersionAsync(cancellation);
             return new LedgerTestResult() { Success = true };
         }
 
-        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network, int account)
+        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network, int account, CancellationToken cancellation)
         {
             if (network == null)
                 throw new ArgumentNullException(nameof(network));
 
             var segwit = network.NBitcoinNetwork.Consensus.SupportSegwit;
             var path = network.GetRootKeyPath().Derive(account, true);
-            var pubkey = await GetExtPubKey(_Ledger, network, path, false);
+            var pubkey = await GetExtPubKey(Ledger, network, path, false, cancellation);
             var derivation = new DerivationStrategyFactory(network.NBitcoinNetwork).CreateDirectDerivationStrategy(pubkey, new DerivationStrategyOptions()
             {
                 P2SH = segwit,
@@ -108,11 +104,11 @@ namespace BTCPayServer.Services
             return new GetXPubResult() { ExtPubKey = derivation.ToString(), KeyPath = path };
         }
 
-        private static async Task<BitcoinExtPubKey> GetExtPubKey(LedgerClient ledger, BTCPayNetwork network, KeyPath account, bool onlyChaincode)
+        private static async Task<BitcoinExtPubKey> GetExtPubKey(LedgerClient ledger, BTCPayNetwork network, KeyPath account, bool onlyChaincode, CancellationToken cancellation)
         {
             try
             {
-                var pubKey = await ledger.GetWalletPubKeyAsync(account);
+                var pubKey = await ledger.GetWalletPubKeyAsync(account, cancellation: cancellation);
                 try
                 {
                     pubKey.GetAddress(network.NBitcoinNetwork);
@@ -122,7 +118,7 @@ namespace BTCPayServer.Services
                     if (network.NBitcoinNetwork.NetworkType == NetworkType.Mainnet)
                         throw new Exception($"The opened ledger app does not seems to support {network.NBitcoinNetwork.Name}.");
                 }
-                var fingerprint = onlyChaincode ? new byte[4] : (await ledger.GetWalletPubKeyAsync(account.Parent)).UncompressedPublicKey.Compress().Hash.ToBytes().Take(4).ToArray();
+                var fingerprint = onlyChaincode ? new byte[4] : (await ledger.GetWalletPubKeyAsync(account.Parent, cancellation: cancellation)).UncompressedPublicKey.Compress().Hash.ToBytes().Take(4).ToArray();
                 var extpubkey = new ExtPubKey(pubKey.UncompressedPublicKey.Compress(), pubKey.ChainCode, (byte)account.Indexes.Length, fingerprint, account.Indexes.Last()).GetWif(network.NBitcoinNetwork);
                 return extpubkey;
             }
@@ -132,7 +128,7 @@ namespace BTCPayServer.Services
             }
         }
 
-        public async Task<KeyPath> GetKeyPath(BTCPayNetwork network, DirectDerivationStrategy directStrategy)
+        public async Task<KeyPath> GetKeyPath(BTCPayNetwork network, DirectDerivationStrategy directStrategy, CancellationToken cancellation)
         {
             List<KeyPath> derivations = new List<KeyPath>();
             if (network.NBitcoinNetwork.Consensus.SupportSegwit)
@@ -146,7 +142,7 @@ namespace BTCPayServer.Services
             {
                 try
                 {
-                    var extpubkey = await GetExtPubKey(_Ledger, network, account, true);
+                    var extpubkey = await GetExtPubKey(Ledger, network, account, true, cancellation);
                     if (directStrategy.Root.PubKey == extpubkey.ExtPubKey.PubKey)
                     {
                         foundKeyPath = account;
@@ -164,15 +160,15 @@ namespace BTCPayServer.Services
 
         public async Task<Transaction> SignTransactionAsync(SignatureRequest[] signatureRequests,
                                                      Transaction unsigned,
-                                                     KeyPath changeKeyPath)
+                                                     KeyPath changeKeyPath,
+                                                     CancellationToken cancellationToken)
         {
-            _Transport.Timeout = TimeSpan.FromMinutes(5);
-            return await Ledger.SignTransactionAsync(signatureRequests, unsigned, changeKeyPath);
+            return await Ledger.SignTransactionAsync(signatureRequests, unsigned, changeKeyPath, cancellationToken);
         }
 
         public void Dispose()
         {
-            if(_Transport != null)
+            if (_Transport != null)
                 _Transport.Dispose();
         }
     }

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -709,7 +709,8 @@ namespace BTCPayServer.Services.Invoices
             accounting.Due = Money.Max(accounting.TotalDue - accounting.Paid, Money.Zero);
             accounting.DueUncapped = accounting.TotalDue - accounting.Paid;
             accounting.NetworkFee = accounting.TotalDue - totalDueNoNetworkCost;
-            accounting.MinimumTotalDue = Money.Max(Money.Satoshis(1), Money.Satoshis(accounting.TotalDue.Satoshi * (1.0m - ((decimal)ParentEntity.PaymentTolerance / 100.0m))));
+            var minimumTotalDueSatoshi = Math.Max(1.0m, accounting.TotalDue.Satoshi * (1.0m - ((decimal)ParentEntity.PaymentTolerance / 100.0m)));
+            accounting.MinimumTotalDue = Money.Satoshis(minimumTotalDueSatoshi);
             return accounting;
         }
 

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -19,6 +19,7 @@ using System.Globalization;
 using BTCPayServer.Models.InvoicingModels;
 using BTCPayServer.Logging;
 using BTCPayServer.Payments;
+using System.Data.Common;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -101,7 +102,7 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        public async Task<InvoiceEntity> CreateInvoiceAsync(string storeId, InvoiceEntity invoice, IEnumerable<string> creationLogs, BTCPayNetworkProvider networkProvider)
+        public async Task<InvoiceEntity> CreateInvoiceAsync(string storeId, InvoiceEntity invoice, InvoiceLogs creationLogs, BTCPayNetworkProvider networkProvider)
         {
             List<string> textSearch = new List<string>();
             invoice = Clone(invoice, null);
@@ -147,13 +148,13 @@ namespace BTCPayServer.Services.Invoices
                 }
                 context.PendingInvoices.Add(new PendingInvoiceData() { Id = invoice.Id });
 
-                foreach(var log in creationLogs)
+                foreach(var log in creationLogs.ToList())
                 {
                     context.InvoiceEvents.Add(new InvoiceEventData()
                     {
                         InvoiceDataId = invoice.Id,
-                        Message = log,
-                        Timestamp = invoice.InvoiceTime,
+                        Message = log.Log,
+                        Timestamp = log.Timestamp,
                         UniqueId = Encoders.Hex.EncodeData(RandomUtils.GetBytes(10))
                     });
                 }
@@ -244,7 +245,11 @@ namespace BTCPayServer.Services.Invoices
                     Timestamp = DateTimeOffset.UtcNow,
                     UniqueId = Encoders.Hex.EncodeData(RandomUtils.GetBytes(10))
                 });
-                await context.SaveChangesAsync();
+                try
+                {
+                    await context.SaveChangesAsync();
+                }
+                catch(DbUpdateException) { } // Probably the invoice does not exists anymore
             }
         }
 

BTCPayServer/Services/LightningConfigurationProvider.cs

@@ -10,10 +10,9 @@ namespace BTCPayServer.Services
     public class LightningConfigurationProvider
     {
         ConcurrentDictionary<ulong, (DateTimeOffset expiration, LightningConfigurations config)> _Map = new ConcurrentDictionary<ulong, (DateTimeOffset expiration, LightningConfigurations config)>();
-        public ulong KeepConfig(LightningConfigurations configuration)
+        public ulong KeepConfig(ulong secret, LightningConfigurations configuration)
         {
             CleanExpired();
-            var secret = RandomUtils.GetUInt64();
             _Map.AddOrReplace(secret, (DateTimeOffset.UtcNow + TimeSpan.FromMinutes(10), configuration));
             return secret;
         }

BTCPayServer/Views/Server/Services.cshtml

@@ -37,7 +37,7 @@
                                 <td>@lnd.Crypto</td>
                                 <td>@lnd.Type</td>
                                 <td style="text-align:right">
-                                    <a asp-action="LNDGRPCServices" asp-route-cryptoCode="@lnd.Crypto">See information</a>
+                                    <a asp-action="LNDGRPCServices" asp-route-cryptoCode="@lnd.Crypto" asp-route-index="@lnd.Index">See information</a>
                                 </td>
                             </tr>
                         }

BTCPayServer/Views/Stores/Wallet.cshtml

@@ -5,7 +5,7 @@
 }
 
 <h4>@ViewData["Title"]</h4>
-<div class="alert alert-danger alert-dismissible" style="display:none;" role="alert">
+<div id="walletAlert" class="alert alert-danger alert-dismissible" style="display:none;" role="alert">
     <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">&times;</span></button>
     <span id="alertMessage"></span>
 </div>

BTCPayServer/wwwroot/js/StoreWallet.js

@@ -6,11 +6,11 @@
     var cryptoCode = $("#cryptoCode").val();
 
     function WriteAlert(type, message) {
-        $(".alert").removeClass("alert-danger");
-        $(".alert").removeClass("alert-warning");
-        $(".alert").removeClass("alert-success");
-        $(".alert").addClass("alert-" + type);
-        $(".alert").css("display", "block");
+        $("#walletAlert").removeClass("alert-danger");
+        $("#walletAlert").removeClass("alert-warning");
+        $("#walletAlert").removeClass("alert-success");
+        $("#walletAlert").addClass("alert-" + type);
+        $("#walletAlert").css("display", "block");
         $("#alertMessage").text(message);
     }
 

README.md

@@ -32,6 +32,7 @@ In addition to Bitcoin, we support the following crypto currencies:
 * Monacoin
 * Polis
 * UFO
+* Viacoin
 
 ## Documentation