bump

This reverts commit 1619666befd4bf8931a11a8c2927de4c5b1add86.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Report a problem
+about: File a technical problem or report a bug
+---
+
+**Describe the problem/bug**
+A clear and concise description of what the bug is.
+
+**Your environment**
+* Version of BTCPay Server:
+* Deployment method: 
+* Other relevant environment details:
+
+**Logs (if applicable)**
+Basic logs can be found in Server Settings > Logs.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Actual behavior**
+Tell us what happens instead
+
+**Screenshots/Links**
+If applicable, add screenshots or links to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Ideas and feature requests
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Provide examples**
+If applicable provide examples, wireframes, sketches or images to better explain your idea.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
       <PrivateAssets>all</PrivateAssets>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -35,6 +35,7 @@ using System.Text;
 using System.Threading;
 using Xunit;
 using BTCPayServer.Services;
+using System.Net.Http;
 
 namespace BTCPayServer.Tests
 {
@@ -120,7 +121,8 @@ namespace BTCPayServer.Tests
             File.WriteAllText(confPath, config.ToString());
 
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
-
+            HttpClient = new HttpClient();
+            HttpClient.BaseAddress = ServerUri;
             Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
             var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath, "--disable-registration", "false" });
             _Host = new WebHostBuilder()
@@ -129,6 +131,7 @@ namespace BTCPayServer.Tests
                     {
                         s.AddLogging(l =>
                         {
+                            l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
                             l.SetMinimumLevel(LogLevel.Information)
                             .AddFilter("Microsoft", LogLevel.Error)
                             .AddFilter("Hangfire", LogLevel.Error)
@@ -208,6 +211,8 @@ namespace BTCPayServer.Tests
             }
         }
 
+        public HttpClient HttpClient { get; set; }
+
         public string HostName
         {
             get;

BTCPayServer.Tests/ChangellyTests.cs

@@ -218,7 +218,7 @@ namespace BTCPayServer.Tests
                     tester.NetworkProvider, fetcher);
                 changellyController.IsTest = true;
                 Assert.IsType<decimal>(Assert
-                    .IsType<OkObjectResult>(await changellyController.CalculateAmount(user.StoreId, "ltc", "btc", 1.0m))
+                    .IsType<OkObjectResult>(await changellyController.CalculateAmount(user.StoreId, "ltc", "btc", 1.0m, default))
                     .Value);
             }
         }

BTCPayServer.Tests/CrowdfundTests.cs

@@ -5,10 +5,8 @@ using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Controllers;
-using BTCPayServer.Crowdfund;
 using BTCPayServer.Data;
 using BTCPayServer.Events;
-using BTCPayServer.Hubs;
 using BTCPayServer.Models;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Models.StoreViewModels;
@@ -25,6 +23,7 @@ using NBitcoin;
 using NBitpayClient;
 using Xunit;
 using Xunit.Abstractions;
+using static BTCPayServer.Tests.UnitTest1;
 
 namespace BTCPayServer.Tests
 {
@@ -110,7 +109,7 @@ namespace BTCPayServer.Tests
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(0.01)
-                }));
+                }, default));
                 
                 Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
                 
@@ -119,7 +118,7 @@ namespace BTCPayServer.Tests
                 {
                     RedirectToCheckout = false,
                     Amount = new decimal(0.01)
-                }));
+                }, default));
                 Assert.IsType<ViewResult>(await publicApps.ViewCrowdfund(appId, string.Empty));
                 Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
                 
@@ -131,7 +130,7 @@ namespace BTCPayServer.Tests
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(0.01)
-                }));
+                }, default));
                 
                 //Scenario 4: Enabled But End Date < Now - Not Allowed
                 
@@ -143,7 +142,7 @@ namespace BTCPayServer.Tests
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(0.01)
-                }));
+                }, default));
                 
                 
                 //Scenario 5: Enabled and within correct timeframe, however target is enforced and Amount is Over - Not Allowed
@@ -157,13 +156,13 @@ namespace BTCPayServer.Tests
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(1.01)
-                }));
+                }, default));
                 
                 //Scenario 6: Allowed
                 Assert.IsType<OkObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(0.05)
-                }));
+                }, default));
                 
             }
         }
@@ -178,6 +177,7 @@ namespace BTCPayServer.Tests
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
+                user.ModifyStore(s => s.NetworkFeeMode = NetworkFeeMode.Never);
                 var apps = user.GetController<AppsController>();
                 var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
                 vm.Name = "test";
@@ -185,7 +185,8 @@ namespace BTCPayServer.Tests
                 Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
                 var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
                     .Apps[0].Id;
-                
+
+                Logs.Tester.LogInformation("We create an invoice with a hardcap");
                 var crowdfundViewModel = Assert.IsType<UpdateCrowdfundViewModel>(Assert
                     .IsType<ViewResult>(apps.UpdateCrowdfund(appId).Result).Model);
                 crowdfundViewModel.Enabled = true;
@@ -193,6 +194,7 @@ namespace BTCPayServer.Tests
                 crowdfundViewModel.TargetAmount = 100;
                 crowdfundViewModel.TargetCurrency = "BTC";
                 crowdfundViewModel.UseAllStoreInvoices = true;
+                crowdfundViewModel.EnforceTargetAmount = true;
                 Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
                 
                 var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
@@ -209,16 +211,16 @@ namespace BTCPayServer.Tests
                 Assert.Equal(0m, model.Info.CurrentAmount );
                 Assert.Equal(0m, model.Info.CurrentPendingAmount);
                 Assert.Equal(0m, model.Info.ProgressPercentage);
-                
-                
-                
+
+
+                Logs.Tester.LogInformation("Unpaid invoices should show as pending contribution because it is hardcap");
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is true, we can manually create an invoice and it should show as contribution");
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Buyer = new Buyer() { email = "test@fwf.com" },
                     Price = 1m,
                     Currency = "BTC",
                     PosData = "posData",
-                    OrderId = $"{CrowdfundHubStreamer.CrowdfundInvoiceOrderIdPrefix}{appId}",
                     ItemDesc = "Some description",
                     TransactionSpeed = "high",
                     FullNotifications = true
@@ -228,19 +230,69 @@ namespace BTCPayServer.Tests
                 model = Assert.IsType<ViewCrowdfundViewModel>(Assert
                     .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
                 
-                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
-               
-                
-                
-                tester.ExplorerNode.SendToAddress(invoiceAddress,invoice.BtcDue);
-                Assert.Equal(0m ,model.Info.CurrentAmount );
+                Assert.Equal(0m ,model.Info.CurrentAmount);
                 Assert.Equal(1m, model.Info.CurrentPendingAmount);
-                Assert.Equal( 0m, model.Info.ProgressPercentage);
+                Assert.Equal(0m, model.Info.ProgressPercentage);
                 Assert.Equal(1m, model.Info.PendingProgressPercentage);
 
-                
-    
-               
+                Logs.Tester.LogInformation("Let's check current amount change once payment is confirmed");
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, invoice.BtcDue);
+                tester.ExplorerNode.Generate(1); // By default invoice confirmed at 1 block
+                TestUtils.Eventually(() =>
+                {
+                    model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                    Assert.Equal(1m, model.Info.CurrentAmount);
+                    Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                });
+
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is true, let's make sure the invoice is tagged");
+                var invoiceEntity = tester.PayTester.InvoiceRepository.GetInvoice(invoice.Id).GetAwaiter().GetResult();
+                Assert.True(invoiceEntity.Version >= InvoiceEntity.InternalTagSupport_Version);
+                Assert.Contains(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
+
+                crowdfundViewModel.UseAllStoreInvoices = false;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is false, let's make sure the invoice is not tagged");
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                invoiceEntity = tester.PayTester.InvoiceRepository.GetInvoice(invoice.Id).GetAwaiter().GetResult();
+                Assert.DoesNotContain(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
+
+                Logs.Tester.LogInformation("After turning setting a softcap, let's check that only actual payments are counted");
+                crowdfundViewModel.EnforceTargetAmount = false;
+                crowdfundViewModel.UseAllStoreInvoices = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(0.5m));
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(0.2m));
+                TestUtils.Eventually(() =>
+                {
+                    model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                    Assert.Equal(0.7m, model.Info.CurrentPendingAmount);
+                });
             }
 
             

BTCPayServer.Tests/Dockerfile

@@ -1,12 +1,9 @@
-FROM microsoft/dotnet:2.1.500-sdk-alpine3.7 AS builder
+FROM mcr.microsoft.com/dotnet/core/sdk:2.1.505-alpine3.7 AS builder
 ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT false
 RUN apk add --no-cache icu-libs
 ENV LC_ALL en_US.UTF-8
 ENV LANG en_US.UTF-8
 
-# This should be removed soon https://github.com/dotnet/corefx/issues/30003
-RUN apk add --no-cache curl 
-
 WORKDIR /source
 COPY BTCPayServer/BTCPayServer.csproj BTCPayServer/BTCPayServer.csproj
 COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj

BTCPayServer.Tests/MockDelay.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Text;
@@ -35,27 +36,29 @@ namespace BTCPayServer.Tests
             }
         }
 
-        public void Advance(TimeSpan time)
+        public async Task Advance(TimeSpan time)
         {
             _Now += time;
+            List<WaitObj> overdue = new List<WaitObj>();
             lock (waits)
             {
                 foreach (var wait in waits.ToArray())
                 {
                     if (_Now >= wait.Expiration)
                     {
-                        wait.CTS.TrySetResult(true);
+                        overdue.Add(wait);
                         waits.Remove(wait);
                     }
                 }
             }
+            foreach (var o in overdue)
+                o.CTS.TrySetResult(true);
+            try
+            {
+                await Task.WhenAll(overdue.Select(o => o.CTS.Task).ToArray());
+            }
+            catch { }
         }
-
-        public void AdvanceMilliseconds(long milli)
-        {
-            Advance(TimeSpan.FromMilliseconds(milli));
-        }
-
         public override string ToString()
         {
             return _Now.Millisecond.ToString(CultureInfo.InvariantCulture);

BTCPayServer.Tests/Mocks/MockRateProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Rating;
 using BTCPayServer.Services.Rates;
@@ -10,7 +11,7 @@ namespace BTCPayServer.Tests.Mocks
     public class MockRateProvider : IRateProvider
     {
         public ExchangeRates ExchangeRates { get; set; } = new ExchangeRates();
-        public Task<ExchangeRates> GetRatesAsync()
+        public Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
         {
             return Task.FromResult(ExchangeRates);
         }

BTCPayServer.Tests/PaymentRequestTests.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Models.PaymentRequestViewModels;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Changelly.Models;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NBitcoin;
+using NBitpayClient;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class PaymentRequestTests
+    {
+        public PaymentRequestTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanCreateViewUpdateAndDeletePaymentRequest()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                var user2 = tester.NewAccount();
+                user2.GrantAccess();
+
+                var paymentRequestController = user.GetController<PaymentRequestController>();
+                var guestpaymentRequestController = user2.GetController<PaymentRequestController>();
+
+                var request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice",
+                    Currency = "BTC",
+                    Amount = 1,
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                var id = (Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result).RouteValues.Values.First().ToString());
+
+                
+
+                //permission guard for guests editing 
+                Assert
+                    .IsType<NotFoundResult>(guestpaymentRequestController.EditPaymentRequest(id).Result);
+
+                request.Title = "update";
+               Assert.IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(id, request).Result);
+               
+               Assert.Equal(request.Title, Assert.IsType<ViewPaymentRequestViewModel>( Assert.IsType<ViewResult>(paymentRequestController.ViewPaymentRequest(id).Result).Model).Title);
+
+                Assert.False(string.IsNullOrEmpty(id));
+
+                Assert.IsType<ViewPaymentRequestViewModel>(Assert
+                    .IsType<ViewResult>(paymentRequestController.ViewPaymentRequest(id).Result).Model);
+
+                //Delete
+
+                Assert.IsType<ConfirmModel>(Assert
+                    .IsType<ViewResult>(paymentRequestController.RemovePaymentRequestPrompt(id).Result).Model);
+
+
+                Assert.IsType<RedirectToActionResult>(paymentRequestController.RemovePaymentRequest(id).Result);
+
+                Assert
+                    .IsType<NotFoundResult>(paymentRequestController.ViewPaymentRequest(id).Result);
+            }
+        }
+
+        [Fact(Timeout = 60 * 2 * 1000)]
+        [Trait("Integration", "Integration")]
+        public async Task CanPayPaymentRequestWhenPossible()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                var paymentRequestController = user.GetController<PaymentRequestController>();
+
+                Assert.IsType<NotFoundResult>(await paymentRequestController.PayPaymentRequest(Guid.NewGuid().ToString()));
+
+
+                var request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice",
+                    Currency = "BTC",
+                    Amount = 1,
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                var response = Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
+                    .RouteValues.First();
+
+                var invoiceId = Assert
+                    .IsType<OkObjectResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString(), false)).Value
+                    .ToString();
+
+                var actionResult = Assert
+                    .IsType<RedirectToActionResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString()));
+
+                Assert.Equal("Checkout", actionResult.ActionName);
+                Assert.Equal("Invoice", actionResult.ControllerName);
+                Assert.Contains(actionResult.RouteValues, pair => pair.Key == "Id" && pair.Value.ToString() == invoiceId);
+
+                var invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
+                Assert.Equal(1, invoice.Price);
+                
+                request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice with expiry",
+                    Currency = "BTC",
+                    Amount = 1,
+                    ExpiryDate = DateTime.Today.Subtract( TimeSpan.FromDays(2)),
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                
+                response = Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
+                    .RouteValues.First();
+
+                Assert
+                    .IsType<BadRequestObjectResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString(), false));               
+                
+            }
+        }
+    }
+}

BTCPayServer.Tests/ServerTester.cs

@@ -23,6 +23,7 @@ using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Lightning.CLightning;
 using BTCPayServer.Lightning;
 using BTCPayServer.Services;
+using BTCPayServer.Tests.Logging;
 
 namespace BTCPayServer.Tests
 {
@@ -85,9 +86,11 @@ namespace BTCPayServer.Tests
         /// Connect a customer LN node to the merchant LN node
         /// </summary>
         /// <returns></returns>
-        public Task EnsureChannelsSetup()
+        public async Task EnsureChannelsSetup()
         {
-            return BTCPayServer.Lightning.Tests.ConnectChannels.ConnectAll(ExplorerNode, GetLightningSenderClients(), GetLightningDestClients());
+            Logs.Tester.LogInformation("Connecting channels");
+            await BTCPayServer.Lightning.Tests.ConnectChannels.ConnectAll(ExplorerNode, GetLightningSenderClients(), GetLightningDestClients()).ConfigureAwait(false);
+            Logs.Tester.LogInformation("Channels connected");
         }
 
         private IEnumerable<ILightningClient> GetLightningSenderClients()

BTCPayServer.Tests/UnitTest1.cs

@@ -52,6 +52,10 @@ using NBitpayClient.Extensions;
 using BTCPayServer.Services;
 using System.Text.RegularExpressions;
 using BTCPayServer.Events;
+using BTCPayServer.Configuration;
+using System.Security;
+using System.Runtime.CompilerServices;
+using System.Net;
 
 namespace BTCPayServer.Tests
 {
@@ -143,6 +147,45 @@ namespace BTCPayServer.Tests
 #pragma warning restore CS0618
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void CanParseTorrc()
+        {
+            var nl = "\n";
+            var input = "# For the hidden service BTCPayServer" + nl +
+                        "HiddenServiceDir /var/lib/tor/hidden_services/BTCPayServer" + nl +
+                        "# Redirecting to nginx" + nl +
+                        "HiddenServicePort 80 172.19.0.10:81";
+            nl = Environment.NewLine;
+            var expected = "HiddenServiceDir /var/lib/tor/hidden_services/BTCPayServer" + nl +
+                           "HiddenServicePort 80 172.19.0.10:81" + nl;
+            Assert.True(Torrc.TryParse(input, out var torrc));
+            Assert.Equal(expected, torrc.ToString());
+            nl = "\r\n";
+            input = "# For the hidden service BTCPayServer" + nl +
+                        "HiddenServiceDir /var/lib/tor/hidden_services/BTCPayServer" + nl +
+                        "# Redirecting to nginx" + nl +
+                        "HiddenServicePort 80 172.19.0.10:81";
+
+            Assert.True(Torrc.TryParse(input, out torrc));
+            Assert.Equal(expected, torrc.ToString());
+
+            input = "# For the hidden service BTCPayServer" + nl +
+                        "HiddenServiceDir /var/lib/tor/hidden_services/BTCPayServer" + nl +
+                        "# Redirecting to nginx" + nl +
+                        "HiddenServicePort 80 172.19.0.10:80" + nl +
+                        "HiddenServiceDir /var/lib/tor/hidden_services/Woocommerce" + nl +
+                        "# Redirecting to nginx" + nl +
+                        "HiddenServicePort 80 172.19.0.11:80";
+            nl = Environment.NewLine;
+            expected = "HiddenServiceDir /var/lib/tor/hidden_services/BTCPayServer" + nl +
+                           "HiddenServicePort 80 172.19.0.10:80" + nl +
+                           "HiddenServiceDir /var/lib/tor/hidden_services/Woocommerce" + nl +
+                           "HiddenServicePort 80 172.19.0.11:80" + nl;
+            Assert.True(Torrc.TryParse(input, out torrc));
+            Assert.Equal(expected, torrc.ToString());
+        }
+
         [Fact]
         [Trait("Fast", "Fast")]
         public void CanCalculateCryptoDue()
@@ -358,7 +401,7 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact(Timeout = 60 * 1000)]
+        [Fact(Timeout = 60 * 2 * 1000)]
         [Trait("Integration", "Integration")]
         public async Task CanSetLightningServer()
         {
@@ -396,21 +439,21 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = 60 * 2 * 1000)]
         [Trait("Integration", "Integration")]
         public async Task CanSendLightningPaymentCLightning()
         {
             await ProcessLightningPayment(LightningConnectionType.CLightning);
         }
 
-        [Fact]
+        [Fact(Timeout = 60 * 2 * 1000)]
         [Trait("Integration", "Integration")]
         public async Task CanSendLightningPaymentCharge()
         {
             await ProcessLightningPayment(LightningConnectionType.Charge);
         }
 
-        [Fact(Timeout = 60 * 1000)]
+        [Fact(Timeout = 60 * 2 * 1000)]
         [Trait("Integration", "Integration")]
         public async Task CanSendLightningPaymentLnd()
         {
@@ -450,7 +493,9 @@ namespace BTCPayServer.Tests
                 ItemDesc = "Some description"
             });
             await Task.Delay(TimeSpan.FromMilliseconds(1000)); // Give time to listen the new invoices
+            Logs.Tester.LogInformation($"Trying to send Lightning payment to {invoice.Id}");
             await tester.SendLightningPaymentAsync(invoice);
+            Logs.Tester.LogInformation($"Lightning payment to {invoice.Id} is sent");
             await TestUtils.EventuallyAsync(async () =>
             {
                 var localInvoice = await user.BitPay.GetInvoiceAsync(invoice.Id);
@@ -473,7 +518,6 @@ namespace BTCPayServer.Tests
                 var controller = acc.GetController<StoresController>();
                 var token = (RedirectToActionResult)controller.CreateToken(new Models.StoreViewModels.CreateTokenViewModel()
                 {
-                    Facade = Facade.Merchant.ToString(),
                     Label = "bla",
                     PublicKey = null
                 }).GetAwaiter().GetResult();
@@ -586,7 +630,7 @@ namespace BTCPayServer.Tests
             Assert.True(RateRules.TryParse("X_X=kraken(X_BTC) * kraken(BTC_X)", out var rule));
             foreach (var pair in new[] { "DOGE_USD", "DOGE_CAD", "DASH_CAD", "DASH_USD", "DASH_EUR" })
             {
-                var result = fetcher.FetchRate(CurrencyPair.Parse(pair), rule).GetAwaiter().GetResult();
+                var result = fetcher.FetchRate(CurrencyPair.Parse(pair), rule, default).GetAwaiter().GetResult();
                 Assert.NotNull(result.BidAsk);
                 Assert.Empty(result.Errors);
             }
@@ -715,20 +759,32 @@ namespace BTCPayServer.Tests
                 acc.RegisterDerivationScheme("LTC");
 
                 var rateController = acc.GetController<RateController>();
-                var GetBaseCurrencyRatesResult = JObject.Parse(((JsonResult)rateController.GetBaseCurrencyRates("BTC", acc.StoreId)
+                var GetBaseCurrencyRatesResult = JObject.Parse(((JsonResult)rateController.GetBaseCurrencyRates("BTC", acc.StoreId, default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate[]>>();
                 Assert.NotNull(GetBaseCurrencyRatesResult);
                 Assert.NotNull(GetBaseCurrencyRatesResult.Data);
                 Assert.Equal(2, GetBaseCurrencyRatesResult.Data.Length);
                 Assert.Single(GetBaseCurrencyRatesResult.Data.Where(o => o.Code == "LTC"));
 
-                var GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, acc.StoreId)
+                var GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, acc.StoreId, default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate[]>>();
+                // We don't have any default currencies, so this should be failing
+                Assert.Null(GetRatesResult?.Data);
+
+                var store = acc.GetController<StoresController>();
+                var ratesVM = (RatesViewModel)(Assert.IsType<ViewResult>(store.Rates(acc.StoreId)).Model);
+                ratesVM.DefaultCurrencyPairs = "BTC_USD,LTC_USD";
+                store.Rates(ratesVM).Wait();
+                store = acc.GetController<StoresController>();
+                rateController = acc.GetController<RateController>();
+                GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, acc.StoreId, default)
+                    .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate[]>>();
+                // Now we should have a result
                 Assert.NotNull(GetRatesResult);
                 Assert.NotNull(GetRatesResult.Data);
                 Assert.Equal(2, GetRatesResult.Data.Length);
 
-                var GetCurrencyPairRateResult = JObject.Parse(((JsonResult)rateController.GetCurrencyPairRate("BTC", "LTC", acc.StoreId)
+                var GetCurrencyPairRateResult = JObject.Parse(((JsonResult)rateController.GetCurrencyPairRate("BTC", "LTC", acc.StoreId, default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate>>();
 
                 Assert.NotNull(GetCurrencyPairRateResult);
@@ -859,6 +915,44 @@ namespace BTCPayServer.Tests
             Assert.Equal(f1.ToString(), f2.ToString());
         }
 
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CheckCORSSetOnBitpayAPI()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                foreach (var req in new[]
+                {
+                    "invoices/",
+                    "invoices",
+                    "rates",
+                    "tokens"
+                }.Select(async path =>
+                {
+                    using (HttpClient client = new HttpClient())
+                    {
+                        HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Options, tester.PayTester.ServerUri.AbsoluteUri + path);
+                        message.Headers.Add("Access-Control-Request-Headers", "test");
+                        var response = await client.SendAsync(message);
+                        response.EnsureSuccessStatusCode();
+                        Assert.True(response.Headers.TryGetValues("Access-Control-Allow-Origin", out var val));
+                        Assert.Equal("*", val.FirstOrDefault());
+                        Assert.True(response.Headers.TryGetValues("Access-Control-Allow-Headers", out val));
+                        Assert.Equal("test", val.FirstOrDefault());
+                    }
+                }).ToList())
+                {
+                    await req;
+                }
+                HttpClient client2 = new HttpClient();
+                HttpRequestMessage message2 = new HttpRequestMessage(HttpMethod.Options, tester.PayTester.ServerUri.AbsoluteUri + "rates");
+                var response2 = await client2.SendAsync(message2);
+                Assert.True(response2.Headers.TryGetValues("Access-Control-Allow-Origin", out var val2));
+                Assert.Equal("*", val2.FirstOrDefault());
+            }
+        }
+
         [Fact]
         [Trait("Integration", "Integration")]
         public void TestAccessBitpayAPI()
@@ -877,7 +971,6 @@ namespace BTCPayServer.Tests
                 var storeController = user.GetController<StoresController>();
                 storeController.CreateToken(new CreateTokenViewModel()
                 {
-                    Facade = Facade.Merchant.ToString(),
                     Label = "test2",
                     StoreId = user.StoreId
                 }).GetAwaiter().GetResult();
@@ -965,7 +1058,7 @@ namespace BTCPayServer.Tests
         private static decimal CreateInvoice(ServerTester tester, TestAccount user, string exchange, string currency = "USD")
         {
             var storeController = user.GetController<StoresController>();
-            var vm = (RatesViewModel)((ViewResult)storeController.Rates()).Model;
+            var vm = (RatesViewModel)((ViewResult)storeController.Rates(user.StoreId)).Model;
             vm.PreferredExchange = exchange;
             storeController.Rates(vm).Wait();
             var invoice2 = user.BitPay.CreateInvoice(new Invoice()
@@ -980,6 +1073,49 @@ namespace BTCPayServer.Tests
             return invoice2.CryptoInfo[0].Rate;
         }
 
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanUseAnyoneCanCreateInvoice()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                Logs.Tester.LogInformation("StoreId without anyone can create invoice = 401");
+                var response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices?storeId={user.StoreId}")
+                {
+                    Content = new StringContent("{\"Price\": 5000, \"currency\": \"USD\"}", Encoding.UTF8, "application/json"),
+                });
+                Assert.Equal(401, (int)response.StatusCode);
+
+                Logs.Tester.LogInformation("No store without  anyone can create invoice = 404 because the bitpay API can't know the storeid");
+                response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices")
+                {
+                    Content = new StringContent("{\"Price\": 5000, \"currency\": \"USD\"}", Encoding.UTF8, "application/json"),
+                });
+                Assert.Equal(404, (int)response.StatusCode);
+
+                user.ModifyStore(s => s.AnyoneCanCreateInvoice = true);
+
+                Logs.Tester.LogInformation("Bad store with anyone can create invoice = 401");
+                response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices?storeId=badid")
+                {
+                    Content = new StringContent("{\"Price\": 5000, \"currency\": \"USD\"}", Encoding.UTF8, "application/json"),
+                });
+                Assert.Equal(401, (int)response.StatusCode);
+
+                Logs.Tester.LogInformation("Good store with anyone can create invoice = 200");
+                response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices?storeId={user.StoreId}")
+                {
+                    Content = new StringContent("{\"Price\": 5000, \"currency\": \"USD\"}", Encoding.UTF8, "application/json"),
+                });
+                Assert.Equal(200, (int)response.StatusCode);
+            }
+        }
+
         [Fact]
         [Trait("Integration", "Integration")]
         public void CanTweakRate()
@@ -1003,7 +1139,7 @@ namespace BTCPayServer.Tests
                 Assert.Equal(Money.Coins(1.0m), invoice1.BtcPrice);
 
                 var storeController = user.GetController<StoresController>();
-                var vm = (RatesViewModel)((ViewResult)storeController.Rates()).Model;
+                var vm = (RatesViewModel)((ViewResult)storeController.Rates(user.StoreId)).Model;
                 Assert.Equal(0.0, vm.Spread);
                 vm.Spread = 40;
                 storeController.Rates(vm).Wait();
@@ -1102,7 +1238,7 @@ namespace BTCPayServer.Tests
                 user.RegisterDerivationScheme("BTC");
 
                 var store = user.GetController<StoresController>();
-                var rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
+                var rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
                 Assert.False(rateVm.ShowScripting);
                 Assert.Equal("coinaverage", rateVm.PreferredExchange);
                 Assert.Equal(0.0, rateVm.Spread);
@@ -1110,7 +1246,7 @@ namespace BTCPayServer.Tests
 
                 rateVm.PreferredExchange = "bitflyer";
                 Assert.IsType<RedirectToActionResult>(store.Rates(rateVm, "Save").Result);
-                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
+                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
                 Assert.Equal("bitflyer", rateVm.PreferredExchange);
 
                 rateVm.ScriptTest = "BTC_JPY,BTC_CAD";
@@ -1127,7 +1263,8 @@ namespace BTCPayServer.Tests
                 Assert.IsType<RedirectToActionResult>(store.ShowRateRulesPost(true).Result);
                 Assert.IsType<RedirectToActionResult>(store.Rates(rateVm, "Save").Result);
                 store = user.GetController<StoresController>();
-                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
+                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
+                Assert.Equal(rateVm.StoreId, user.StoreId);
                 Assert.Equal(rateVm.DefaultScript, rateVm.Script);
                 Assert.True(rateVm.ShowScripting);
                 rateVm.ScriptTest = "BTC_JPY";
@@ -1144,7 +1281,7 @@ namespace BTCPayServer.Tests
                 Assert.True(rateVm.TestRateRules.All(t => !t.Error));
                 Assert.IsType<RedirectToActionResult>(store.Rates(rateVm, "Save").Result);
                 store = user.GetController<StoresController>();
-                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
+                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
                 Assert.Equal(50, rateVm.Spread);
                 Assert.True(rateVm.ShowScripting);
                 Assert.Contains("DOGE_X", rateVm.Script, StringComparison.OrdinalIgnoreCase);
@@ -1260,6 +1397,25 @@ namespace BTCPayServer.Tests
                 Assert.True(invoice.SupportedTransactionCurrencies["LTC"].Enabled);
                 Assert.True(invoice.PaymentSubtotals.ContainsKey("LTC"));
                 Assert.True(invoice.PaymentTotals.ContainsKey("LTC"));
+
+
+                // Check if we can disable LTC
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 5000.0m,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true,
+                    SupportedTransactionCurrencies = new Dictionary<string, InvoiceSupportedTransactionCurrency>()
+                    {
+                        { "BTC", new InvoiceSupportedTransactionCurrency() { Enabled = true } }
+                    }
+                }, Facade.Merchant);
+
+                Assert.Single(invoice.CryptoInfo.Where(c => c.CryptoCode == "BTC"));
+                Assert.Empty(invoice.CryptoInfo.Where(c => c.CryptoCode == "LTC"));
             }
         }
 
@@ -1397,7 +1553,7 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact(Timeout = 60 * 1000)]
+        [Fact(Timeout = 60 * 2 * 1000)]
         [Trait("Integration", "Integration")]
         public async Task CanSetPaymentMethodLimits()
         {
@@ -1552,21 +1708,20 @@ donation:
 
         [Fact]
         [Trait("Fast", "Fast")]
-        public void CanScheduleBackgroundTasks()
+        public async Task CanScheduleBackgroundTasks()
         {
             BackgroundJobClient client = new BackgroundJobClient();
             MockDelay mockDelay = new MockDelay();
             client.Delay = mockDelay;
             bool[] jobs = new bool[4];
-#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
             Logs.Tester.LogInformation("Start Job[0] in 5 sec");
-            client.Schedule(async () => { Logs.Tester.LogInformation("Job[0]"); jobs[0] = true; }, TimeSpan.FromSeconds(5.0));
+            client.Schedule((_) => { Logs.Tester.LogInformation("Job[0]"); jobs[0] = true; return Task.CompletedTask; }, TimeSpan.FromSeconds(5.0));
             Logs.Tester.LogInformation("Start Job[1] in 2 sec");
-            client.Schedule(async () => { Logs.Tester.LogInformation("Job[1]"); jobs[1] = true; }, TimeSpan.FromSeconds(2.0));
+            client.Schedule((_) => { Logs.Tester.LogInformation("Job[1]"); jobs[1] = true; return Task.CompletedTask; }, TimeSpan.FromSeconds(2.0));
             Logs.Tester.LogInformation("Start Job[2] fails in 6 sec");
-            client.Schedule(async () => { jobs[2] = true; throw new Exception("Job[2]"); }, TimeSpan.FromSeconds(6.0));
+            client.Schedule((_) => { jobs[2] = true; throw new Exception("Job[2]"); }, TimeSpan.FromSeconds(6.0));
             Logs.Tester.LogInformation("Start Job[3] starts in in 7 sec");
-            client.Schedule(async () => { Logs.Tester.LogInformation("Job[3]"); jobs[3] = true; }, TimeSpan.FromSeconds(7.0));
+            client.Schedule((_) => { Logs.Tester.LogInformation("Job[3]"); jobs[3] = true; return Task.CompletedTask; }, TimeSpan.FromSeconds(7.0));
 
             Assert.True(new[] { false, false, false, false }.SequenceEqual(jobs));
             CancellationTokenSource cts = new CancellationTokenSource();
@@ -1576,52 +1731,52 @@ donation:
 
             var waitJobsFinish = client.WaitAllRunning(default);
 
-            mockDelay.Advance(TimeSpan.FromSeconds(2.0));
+            await mockDelay.Advance(TimeSpan.FromSeconds(2.0));
             Assert.True(new[] { false, true, false, false }.SequenceEqual(jobs));
 
-            mockDelay.Advance(TimeSpan.FromSeconds(3.0));
+            await mockDelay.Advance(TimeSpan.FromSeconds(3.0));
             Assert.True(new[] { true, true, false, false }.SequenceEqual(jobs));
 
-            mockDelay.Advance(TimeSpan.FromSeconds(1.0));
+            await mockDelay.Advance(TimeSpan.FromSeconds(1.0));
             Assert.True(new[] { true, true, true, false }.SequenceEqual(jobs));
             Assert.Equal(1, client.GetExecutingCount());
 
-            Assert.False(waitJobsFinish.Wait(100));
+            Assert.False(waitJobsFinish.Wait(1));
             Assert.False(waitJobsFinish.IsCompletedSuccessfully);
 
-            mockDelay.Advance(TimeSpan.FromSeconds(1.0));
+            await mockDelay.Advance(TimeSpan.FromSeconds(1.0));
             Assert.True(new[] { true, true, true, true }.SequenceEqual(jobs));
 
-            Assert.True(waitJobsFinish.Wait(100));
+            await waitJobsFinish;
             Assert.True(waitJobsFinish.IsCompletedSuccessfully);
             Assert.True(!waitJobsFinish.IsFaulted);
             Assert.Equal(0, client.GetExecutingCount());
 
             bool jobExecuted = false;
             Logs.Tester.LogInformation("This job will be cancelled");
-            client.Schedule(async () => { jobExecuted = true; }, TimeSpan.FromSeconds(1.0));
-            mockDelay.Advance(TimeSpan.FromSeconds(0.5));
+            client.Schedule((_) => { jobExecuted = true; return Task.CompletedTask; }, TimeSpan.FromSeconds(1.0));
+            await mockDelay.Advance(TimeSpan.FromSeconds(0.5));
             Assert.False(jobExecuted);
-            Thread.Sleep(100);
-            Assert.Equal(1, client.GetExecutingCount());
+            TestUtils.Eventually(() => Assert.Equal(1, client.GetExecutingCount()));
 
 
             waitJobsFinish = client.WaitAllRunning(default);
             Assert.False(waitJobsFinish.Wait(100));
             cts.Cancel();
-            Assert.True(waitJobsFinish.Wait(1000));
+            await waitJobsFinish;
+            Assert.True(waitJobsFinish.Wait(1));
             Assert.True(waitJobsFinish.IsCompletedSuccessfully);
-            Assert.True(!waitJobsFinish.IsFaulted);
+            Assert.False(waitJobsFinish.IsFaulted);
             Assert.False(jobExecuted);
 
-            mockDelay.Advance(TimeSpan.FromSeconds(1.0));
-            Thread.Sleep(100); // Make sure it get cancelled
+            await mockDelay.Advance(TimeSpan.FromSeconds(1.0));
 
             Assert.False(jobExecuted);
             Assert.Equal(0, client.GetExecutingCount());
+
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await processing);
             Assert.True(processing.IsCanceled);
             Assert.True(client.WaitAllRunning(default).Wait(100));
-#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
         }
 
         [Fact]
@@ -1940,31 +2095,48 @@ donation:
                 var invoice1 = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 0.000000012m,
-                    Currency = "BTC",
-                    PosData = "posData",
-                    OrderId = "orderId",
-                    ItemDesc = "Some description",
+                    Currency = "USD",
                     FullNotifications = true
                 }, Facade.Merchant);
                 var invoice2 = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 0.000000019m,
-                    Currency = "BTC",
-                    PosData = "posData",
-                    OrderId = "orderId",
-                    ItemDesc = "Some description",
+                    Currency = "USD"
+                }, Facade.Merchant);
+                Assert.Equal(0.000000012m, invoice1.Price);
+                Assert.Equal(0.000000019m, invoice2.Price);
+
+                // Should round up to 1 because 0.000000019 is unsignificant
+                var invoice3 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 1.000000019m,
+                    Currency = "USD",
                     FullNotifications = true
                 }, Facade.Merchant);
-                Assert.Equal(0.00000001m, invoice1.Price);
-                Assert.Equal(0.00000002m, invoice2.Price);
+                Assert.Equal(1m, invoice3.Price);
+
+                // Should not round up at 8 digit because the 9th is insignificant
+                var invoice4 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 1.000000019m,
+                    Currency = "BTC",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                Assert.Equal(1.00000002m, invoice4.Price);
+
+                // But not if the 9th is insignificant
+                invoice4 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 0.000000019m,
+                    Currency = "BTC",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                Assert.Equal(0.000000019m, invoice4.Price);
 
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = -0.1m,
                     Currency = "BTC",
-                    PosData = "posData",
-                    OrderId = "orderId",
-                    ItemDesc = "Some description",
                     FullNotifications = true
                 }, Facade.Merchant);
                 Assert.Equal(0.0m, invoice.Price);
@@ -2162,7 +2334,7 @@ donation:
             foreach (var result in factory
                 .Providers
                 .Where(p => p.Value is BackgroundFetcherRateProvider)
-                .Select(p => (ExpectedName: p.Key, ResultAsync: p.Value.GetRatesAsync(), Fetcher: (BackgroundFetcherRateProvider)p.Value))
+                .Select(p => (ExpectedName: p.Key, ResultAsync: p.Value.GetRatesAsync(default), Fetcher: (BackgroundFetcherRateProvider)p.Value))
                 .ToList())
             {
                 Logs.Tester.LogInformation($"Testing {result.ExpectedName}");
@@ -2174,17 +2346,25 @@ donation:
                 Assert.NotNull(exchangeRates);
                 Assert.NotEmpty(exchangeRates);
                 Assert.NotEmpty(exchangeRates.ByExchange[result.ExpectedName]);
-
-                // This check if the currency pair is using right currency pair
-                Assert.Contains(exchangeRates.ByExchange[result.ExpectedName],
+                if (result.ExpectedName == "bitbank")
+                {
+                    Assert.Contains(exchangeRates.ByExchange[result.ExpectedName],
+                        e => e.CurrencyPair == new CurrencyPair("BTC", "JPY") && e.BidAsk.Bid > 100m); // 1BTC will always be more than 100JPY
+                }
+                else
+                {
+                    // This check if the currency pair is using right currency pair
+                    Assert.Contains(exchangeRates.ByExchange[result.ExpectedName],
                         e => (e.CurrencyPair == new CurrencyPair("BTC", "USD") ||
                                e.CurrencyPair == new CurrencyPair("BTC", "EUR") ||
-                               e.CurrencyPair == new CurrencyPair("BTC", "USDT"))
+                               e.CurrencyPair == new CurrencyPair("BTC", "USDT") ||
+                               e.CurrencyPair == new CurrencyPair("BTC", "CAD"))
                                && e.BidAsk.Bid > 1.0m // 1BTC will always be more than 1USD
                                );
+                }
             }
             // Kraken emit one request only after first GetRates
-            factory.Providers["kraken"].GetRatesAsync().GetAwaiter().GetResult();
+            factory.Providers["kraken"].GetRatesAsync(default).GetAwaiter().GetResult();
         }
 
         [Fact]
@@ -2200,7 +2380,7 @@ donation:
                     .ToHashSet();
 
             var rules = new StoreBlob().GetDefaultRateRules(provider);
-            var result = fetcher.FetchRates(pairs, rules);
+            var result = fetcher.FetchRates(pairs, rules, default);
             foreach (var value in result)
             {
                 var rateResult = value.Value.GetAwaiter().GetResult();
@@ -2222,7 +2402,7 @@ donation:
         class SpyRateProvider : IRateProvider
         {
             public bool Hit { get; set; }
-            public Task<ExchangeRates> GetRatesAsync()
+            public Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
             {
                 Hit = true;
                 var rates = new ExchangeRates();
@@ -2258,6 +2438,62 @@ donation:
             }
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public async Task CanExpandExternalConnectionString()
+        {
+            var unusedUri = new Uri("https://toto.com");
+            Assert.True(ExternalConnectionString.TryParse("server=/test", out var connStr, out var error));
+            var expanded = await connStr.Expand(new Uri("https://toto.com"), ExternalServiceTypes.Charge);
+            Assert.Equal(new Uri("https://toto.com/test"), expanded.Server);
+            expanded = await connStr.Expand(new Uri("http://toto.onion"), ExternalServiceTypes.Charge);
+            Assert.Equal(new Uri("http://toto.onion/test"), expanded.Server);
+            await Assert.ThrowsAsync<SecurityException>(() => connStr.Expand(new Uri("http://toto.com"), ExternalServiceTypes.Charge));
+
+            // Make sure absolute paths are not expanded
+            Assert.True(ExternalConnectionString.TryParse("server=https://tow/test", out connStr, out error));
+            expanded = await connStr.Expand(new Uri("https://toto.com"), ExternalServiceTypes.Charge);
+            Assert.Equal(new Uri("https://tow/test"), expanded.Server);
+
+            // Error if directory not exists
+            Assert.True(ExternalConnectionString.TryParse($"server={unusedUri};macaroondirectorypath=pouet", out connStr, out error));
+            await Assert.ThrowsAsync<DirectoryNotFoundException>(() => connStr.Expand(unusedUri, ExternalServiceTypes.LNDGRPC));
+            await Assert.ThrowsAsync<DirectoryNotFoundException>(() => connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest));
+            await connStr.Expand(unusedUri, ExternalServiceTypes.Charge);
+
+            var macaroonDirectory = CreateDirectory();
+            Assert.True(ExternalConnectionString.TryParse($"server={unusedUri};macaroondirectorypath={macaroonDirectory}", out connStr, out error));
+            await connStr.Expand(unusedUri, ExternalServiceTypes.LNDGRPC);
+            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest);
+            Assert.NotNull(expanded.Macaroons);
+            Assert.Null(expanded.MacaroonFilePath);
+            Assert.Null(expanded.Macaroons.AdminMacaroon);
+            Assert.Null(expanded.Macaroons.InvoiceMacaroon);
+            Assert.Null(expanded.Macaroons.ReadonlyMacaroon);
+
+            File.WriteAllBytes($"{macaroonDirectory}/admin.macaroon", new byte[] { 0xaa });
+            File.WriteAllBytes($"{macaroonDirectory}/invoice.macaroon", new byte[] { 0xab });
+            File.WriteAllBytes($"{macaroonDirectory}/readonly.macaroon", new byte[] { 0xac });
+            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest);
+            Assert.NotNull(expanded.Macaroons.AdminMacaroon);
+            Assert.NotNull(expanded.Macaroons.InvoiceMacaroon);
+            Assert.Equal("ab", expanded.Macaroons.InvoiceMacaroon.Hex);
+            Assert.Equal(0xab, expanded.Macaroons.InvoiceMacaroon.Bytes[0]);
+            Assert.NotNull(expanded.Macaroons.ReadonlyMacaroon);
+
+            Assert.True(ExternalConnectionString.TryParse($"server={unusedUri};cookiefilepath={macaroonDirectory}/charge.cookie", out connStr, out error));
+            File.WriteAllText($"{macaroonDirectory}/charge.cookie", "apitoken");
+            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.Charge);
+            Assert.Equal("apitoken", expanded.APIToken);
+        }
+
+        private string CreateDirectory([CallerMemberName] string caller = null)
+        {
+            var name = $"{caller}-{NBitcoin.RandomUtils.GetUInt32()}";
+            Directory.CreateDirectory(name);
+            return name;
+        }
+
         [Fact]
         [Trait("Fast", "Fast")]
         public void CheckRatesProvider()
@@ -2273,47 +2509,47 @@ donation:
 
             var fetcher = new RateFetcher(factory);
 
-            var fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            var fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertHit();
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertNotHit();
 
             Thread.Sleep(3000);
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertHit();
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertNotHit();
             // Should cache at exchange level so this should hit the cache
-            var fetchedRate2 = fetcher.FetchRate(CurrencyPair.Parse("LTC_USD"), rateRules).GetAwaiter().GetResult();
+            var fetchedRate2 = fetcher.FetchRate(CurrencyPair.Parse("LTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertNotHit();
             Assert.Null(fetchedRate2.BidAsk);
             Assert.Equal(RateRulesErrors.RateUnavailable, fetchedRate2.Errors.First());
 
             // Should cache at exchange level this should not hit the cache as it is different exchange
             RateRules.TryParse("X_X = bittrex(X_X);", out rateRules);
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertHit();
 
             factory.Providers.Clear();
             var fetch = new BackgroundFetcherRateProvider(spy);
             fetch.DoNotAutoFetchIfExpired = true;
             factory.Providers.Add("bittrex", fetch);
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertHit();
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertNotHit();
-            fetch.UpdateIfNecessary().GetAwaiter().GetResult();
+            fetch.UpdateIfNecessary(default).GetAwaiter().GetResult();
             spy.AssertNotHit();
             fetch.RefreshRate = TimeSpan.FromSeconds(1.0);
             Thread.Sleep(1020);
-            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules).GetAwaiter().GetResult();
+            fetchedRate = fetcher.FetchRate(CurrencyPair.Parse("BTC_USD"), rateRules, default).GetAwaiter().GetResult();
             spy.AssertNotHit();
             fetch.ValidatyTime = TimeSpan.FromSeconds(1.0);
-            fetch.UpdateIfNecessary().GetAwaiter().GetResult();
+            fetch.UpdateIfNecessary(default).GetAwaiter().GetResult();
             spy.AssertHit();
-            fetch.GetRatesAsync().GetAwaiter().GetResult();
+            fetch.GetRatesAsync(default).GetAwaiter().GetResult();
             Thread.Sleep(1000);
-            Assert.Throws<InvalidOperationException>(() => fetch.GetRatesAsync().GetAwaiter().GetResult());
+            Assert.Throws<InvalidOperationException>(() => fetch.GetRatesAsync(default).GetAwaiter().GetResult());
         }
 
         [Fact]
@@ -2324,7 +2560,7 @@ donation:
             var parsed = new StatusMessageModel(legacyStatus);
             Assert.Equal(legacyStatus, parsed.Message);
             Assert.Equal(StatusMessageModel.StatusSeverity.Error, parsed.Severity);
-            
+
             var legacyStatus2 = "Some normal shit happened";
             parsed = new StatusMessageModel(legacyStatus2);
             Assert.Equal(legacyStatus2, parsed.Message);
@@ -2339,7 +2575,7 @@ donation:
             Assert.Null(parsed.Message);
             Assert.Equal(newStatus.Html, parsed.Html);
             Assert.Equal(StatusMessageModel.StatusSeverity.Info, parsed.Severity);
-            
+
             var newStatus2 = new StatusMessageModel()
             {
                 Message = "something new",

BTCPayServer.Tests/docker-compose.yml

@@ -69,7 +69,7 @@ services:
 
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.0.0.8
+    image: nicolasdorier/nbxplorer:2.0.0.27
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -119,7 +119,7 @@ services:
       - "bitcoin_datadir:/data"
 
   customer_lightningd:
-    image: btcpayserver/lightning:v0.6.2-dev
+    image: btcpayserver/lightning:v0.7.0-1-dev
     stop_signal: SIGKILL
     restart: unless-stopped
     environment: 
@@ -165,7 +165,7 @@ services:
       - merchant_lightningd
 
   merchant_lightningd:
-    image: btcpayserver/lightning:v0.6.2-dev
+    image: btcpayserver/lightning:v0.7.0-1-dev
     stop_signal: SIGKILL
     environment: 
       EXPOSE_TCP: "true"
@@ -222,7 +222,7 @@ services:
       - MYSQL_ALLOW_EMPTY_PASSWORD=yes
 
   merchant_lnd:
-    image: btcpayserver/lnd:v0.5.1-beta
+    image: btcpayserver/lnd:v0.5.2-beta
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -252,7 +252,7 @@ services:
       - bitcoind
 
   customer_lnd:
-    image: btcpayserver/lnd:v0.5.1-beta
+    image: btcpayserver/lnd:v0.5.2-beta
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"

BTCPayServer/Authentication/BitToken.cs

@@ -8,10 +8,6 @@ namespace BTCPayServer.Authentication
 {
     public class BitTokenEntity
     {
-        public string Facade
-        {
-            get; set;
-        }
         public string Value
         {
             get; set;
@@ -39,7 +35,6 @@ namespace BTCPayServer.Authentication
             return new BitTokenEntity()
             {
                 Label = Label,
-                Facade = Facade,
                 StoreId = StoreId,
                 PairingTime = PairingTime,
                 SIN = SIN,

BTCPayServer/Authentication/PairingCodeEntity.cs

@@ -11,11 +11,6 @@ namespace BTCPayServer.Authentication
             get;
             set;
         }
-        public string Facade
-        {
-            get;
-            set;
-        }
         public string Label
         {
             get;

BTCPayServer/Authentication/TokenRepository.cs

@@ -90,7 +90,6 @@ namespace BTCPayServer.Authentication
             return new BitTokenEntity()
             {
                 Label = data.Label,
-                Facade = data.Facade,
                 Value = data.Id,
                 SIN = data.SIN,
                 PairingTime = data.PairingTime,
@@ -129,7 +128,6 @@ namespace BTCPayServer.Authentication
             {
                 var pairingCode = await ctx.PairingCodes.FindAsync(pairingCodeEntity.Id);
                 pairingCode.Label = pairingCodeEntity.Label;
-                pairingCode.Facade = pairingCodeEntity.Facade;
                 await ctx.SaveChangesAsync();
                 return CreatePairingCodeEntity(pairingCode);
             }
@@ -178,7 +176,6 @@ namespace BTCPayServer.Authentication
                 {
                     Id = pairingCode.TokenValue,
                     PairingTime = DateTime.UtcNow,
-                    Facade = pairingCode.Facade,
                     Label = pairingCode.Label,
                     StoreDataId = pairingCode.StoreDataId,
                     SIN = pairingCode.SIN
@@ -213,7 +210,6 @@ namespace BTCPayServer.Authentication
                 return null;
             return new PairingCodeEntity()
             {
-                Facade = data.Facade,
                 Id = data.Id,
                 Label = data.Label,
                 Expiration = data.Expiration,

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-		<Version>1.0.3.54</Version>
+		<Version>1.0.3.93</Version>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
@@ -30,25 +30,27 @@
     <None Remove="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="bundleconfig.json" />
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.5" />
-    <PackageReference Include="BuildBundlerMinifier" Version="2.7.385" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.16" />
+    <PackageReference Include="BuildBundlerMinifier" Version="2.9.406" />
+    <PackageReference Include="BundlerMinifier.Core" Version="2.9.406" />
+    <PackageReference Include="BundlerMinifier.TagHelpers" Version="2.9.406" />
     <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.5.3" />
-    <PackageReference Include="HtmlSanitizer" Version="4.0.199" />
+    <PackageReference Include="HtmlSanitizer" Version="4.0.207" />
     <PackageReference Include="LedgerWallet" Version="2.0.0.3" />
-    <PackageReference Include="Meziantou.AspNetCore.BundleTagHelpers" Version="2.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
     <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="NBitcoin" Version="4.1.1.78" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.31" />	  
+    <PackageReference Include="NBitcoin" Version="4.1.1.98" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
     <PackageReference Include="DBreeze" Version="1.92.0" />
-    <PackageReference Include="NBXplorer.Client" Version="2.0.0.3" />
+    <PackageReference Include="NBXplorer.Client" Version="2.0.0.6" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
     <PackageReference Include="NicolasDorier.RateLimits" Version="1.0.0.3" />
@@ -67,7 +69,7 @@
   </ItemGroup>
 
 	<ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.6" />
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
 		<PackageReference Include="YamlDotNet" Version="5.2.1" />
 	</ItemGroup>
 
@@ -139,7 +141,7 @@
     <Content Update="Views\Server\LightningChargeServices.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
-    <Content Update="Views\Server\SparkServices.cshtml">
+    <Content Update="Views\Server\LightningWalletServices.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
     <Content Update="Views\Server\SSHService.cshtml">

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -15,7 +15,6 @@ using Renci.SshNet;
 using NBitcoin.DataEncoders;
 using BTCPayServer.SSH;
 using BTCPayServer.Lightning;
-using BTCPayServer.Configuration.External;
 using Serilog.Events;
 
 namespace BTCPayServer.Configuration
@@ -49,11 +48,7 @@ namespace BTCPayServer.Configuration
             get;
             private set;
         }
-        public List<IPEndPoint> Listen
-        {
-            get;
-            set;
-        }
+        public EndPoint SocksEndpoint { get; set; }
 
         public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
         {
@@ -109,67 +104,26 @@ namespace BTCPayServer.Configuration
                     {
                         if (!LightningConnectionString.TryParse(lightning, true, out var connectionString, out var error))
                         {
-                            throw new ConfigException($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
+                            Logs.Configuration.LogWarning($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
                                 $"If you have a c-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);
+                                $"Error: {error}" + Environment.NewLine +
+                                "This service will not be exposed through BTCPay Server");
                         }
-                        if (connectionString.IsLegacy)
+                        else
                         {
-                            Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning is a deprecated format, it will work now, but please replace it for future versions with '{connectionString.ToString()}'");
+                            if (connectionString.IsLegacy)
+                            {
+                                Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning is a deprecated format, it will work now, but please replace it for future versions with '{connectionString.ToString()}'");
+                            }
+                            InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
                         }
-                        InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
                     }
                 }
 
-                void externalLnd<T>(string code, string lndType)
-                {
-                    var lightning = conf.GetOrDefault<string>(code, string.Empty);
-                    if (lightning.Length != 0)
-                    {
-                        if (!LightningConnectionString.TryParse(lightning, false, out var connectionString, out var error))
-                        {
-                            throw new ConfigException($"Invalid setting {code}, " + Environment.NewLine +
-                                $"lnd server: 'type={lndType};server=https://lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
-                                $"lnd server: 'type={lndType};server=https://lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
-                                error);
-                        }
-                        var instanceType = typeof(T);
-                        ExternalServicesByCryptoCode.Add(net.CryptoCode, (ExternalService)Activator.CreateInstance(instanceType, connectionString));
-                    }
-                };
-
-                externalLnd<ExternalLndGrpc>($"{net.CryptoCode}.external.lnd.grpc", "lnd-grpc");
-                externalLnd<ExternalLndRest>($"{net.CryptoCode}.external.lnd.rest", "lnd-rest");
-
-                var spark = conf.GetOrDefault<string>($"{net.CryptoCode}.external.spark", string.Empty);
-                if (spark.Length != 0)
-                {
-                    if (!SparkConnectionString.TryParse(spark, out var connectionString))
-                    {
-                        throw new ConfigException($"Invalid setting {net.CryptoCode}.external.spark, " + Environment.NewLine +
-                            $"Valid example: 'server=https://btcpay.example.com/spark/btc/;cookiefile=/etc/clightning_bitcoin_spark/.cookie'");
-                    }
-                    ExternalServicesByCryptoCode.Add(net.CryptoCode, new ExternalSpark(connectionString));
-                }
-
-                var charge = conf.GetOrDefault<string>($"{net.CryptoCode}.external.charge", string.Empty);
-                if (charge.Length != 0)
-                {
-                    if (!LightningConnectionString.TryParse(charge, false, out var chargeConnectionString, out var chargeError))
-                        LightningConnectionString.TryParse("type=charge;" + charge, false, out chargeConnectionString, out chargeError);
-
-                    if(chargeConnectionString == null || chargeConnectionString.ConnectionType != LightningConnectionType.Charge)
-                    {
-                        throw new ConfigException($"Invalid setting {net.CryptoCode}.external.charge, " + Environment.NewLine +
-                                $"lightning charge server: 'type=charge;server=https://charge.example.com;api-token=2abdf302...'" + Environment.NewLine +
-                                $"lightning charge server: 'type=charge;server=https://charge.example.com;cookiefilepath=/root/.charge/.cookie'" + Environment.NewLine +
-                                chargeError ?? string.Empty);
-                    }
-                    ExternalServicesByCryptoCode.Add(net.CryptoCode, new ExternalCharge(chargeConnectionString));
-                }
+                ExternalServices.Load(net.CryptoCode, conf);
             }
 
             Logs.Configuration.LogInformation("Supported chains: " + String.Join(',', supportedChains.ToArray()));
@@ -183,14 +137,24 @@ namespace BTCPayServer.Configuration
                                                 .Select(p => (Name: p.p.Substring(0, p.SeparatorIndex), 
                                                               Link: p.p.Substring(p.SeparatorIndex + 1))))
                 {
-                    ExternalServices.AddOrReplace(service.Name, service.Link);
+                    if (Uri.TryCreate(service.Link, UriKind.RelativeOrAbsolute, out var uri))
+                        OtherExternalServices.AddOrReplace(service.Name, uri);
                 }
             }
 
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
             MySQLConnectionString = conf.GetOrDefault<string>("mysql", null);
             BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
-            ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
+            TorrcFile = conf.GetOrDefault<string>("torrcfile", null);
+
+            var socksEndpointString = conf.GetOrDefault<string>("socksendpoint", null);
+            if(!string.IsNullOrEmpty(socksEndpointString))
+            {
+                if (!Utils.TryParseEndpoint(socksEndpointString, 9050, out var endpoint))
+                    throw new ConfigException("Invalid value for socksendpoint");
+                SocksEndpoint = endpoint;
+            }
+            
 
             var sshSettings = ParseSSHConfiguration(conf);
             if ((!string.IsNullOrEmpty(sshSettings.Password) || !string.IsNullOrEmpty(sshSettings.KeyFile)) && !string.IsNullOrEmpty(sshSettings.Server))
@@ -250,7 +214,6 @@ namespace BTCPayServer.Configuration
 
         private SSHSettings ParseSSHConfiguration(IConfiguration conf)
         {
-            var externalUrl = conf.GetOrDefault<Uri>("externalurl", null);
             var settings = new SSHSettings();
             settings.Server = conf.GetOrDefault<string>("sshconnection", null);
             if (settings.Server != null)
@@ -277,12 +240,6 @@ namespace BTCPayServer.Configuration
                     settings.Username = "root";
                 }
             }
-            else if (externalUrl != null)
-            {
-                settings.Port = 22;
-                settings.Username = "root";
-                settings.Server = externalUrl.DnsSafeHost;
-            }
             settings.Password = conf.GetOrDefault<string>("sshpassword", "");
             settings.KeyFile = conf.GetOrDefault<string>("sshkeyfile", "");
             settings.KeyFilePassword = conf.GetOrDefault<string>("sshkeyfilepassword", "");
@@ -296,9 +253,9 @@ namespace BTCPayServer.Configuration
 
         public string RootPath { get; set; }
         public Dictionary<string, LightningConnectionString> InternalLightningByCryptoCode { get; set; } = new Dictionary<string, LightningConnectionString>();
-        public Dictionary<string, string> ExternalServices { get; set; } = new Dictionary<string, string>();
 
-        public ExternalServices ExternalServicesByCryptoCode { get; set; } = new ExternalServices();
+        public Dictionary<string, Uri> OtherExternalServices { get; set; } = new Dictionary<string, Uri>();
+        public ExternalServices ExternalServices { get; set; } = new ExternalServices();
 
         public BTCPayNetworkProvider NetworkProvider { get; set; }
         public string PostgresConnectionString
@@ -311,11 +268,6 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
-        public Uri ExternalUrl
-        {
-            get;
-            set;
-        }
         public bool BundleJsCss
         {
             get;
@@ -327,14 +279,6 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
-
-        internal string GetRootUri()
-        {
-            if (ExternalUrl == null)
-                return null;
-            UriBuilder builder = new UriBuilder(ExternalUrl);
-            builder.Path = RootPath;
-            return builder.ToString();
-        }
+        public string TorrcFile { get; set; }
     }
 }

BTCPayServer/Configuration/ConfigurationExtensions.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Primitives;
+using NBitcoin;
 
 namespace BTCPayServer.Configuration
 {

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -32,7 +32,6 @@ namespace BTCPayServer.Configuration
             app.Option("--chains | -c", $"Chains to support as a comma separated (default: btc; available: {chains})", CommandOptionType.SingleValue);
             app.Option("--postgres", $"Connection string to a PostgreSQL database (default: SQLite)", CommandOptionType.SingleValue);
             app.Option("--mysql", $"Connection string to a MySQL database (default: SQLite)", CommandOptionType.SingleValue);
-            app.Option("--externalurl", $"The expected external URL of this service, to use if BTCPay is behind a reverse proxy (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
             app.Option("--externalservices", $"Links added to external services inside Server Settings / Services under the format service1:path2;service2:path2.(default: empty)", CommandOptionType.SingleValue);
             app.Option("--bundlejscss", $"Bundle JavaScript and CSS files for better performance (default: true)", CommandOptionType.SingleValue);
             app.Option("--rootpath", "The root path in the URL to access BTCPay (default: /)", CommandOptionType.SingleValue);
@@ -41,6 +40,8 @@ namespace BTCPayServer.Configuration
             app.Option("--sshkeyfile", "SSH private key file to manage BTCPay (default: empty)", CommandOptionType.SingleValue);
             app.Option("--sshkeyfilepassword", "Password of the SSH keyfile (default: empty)", CommandOptionType.SingleValue);
             app.Option("--sshtrustedfingerprints", "SSH Host public key fingerprint or sha256 (default: empty, it will allow untrusted connections)", CommandOptionType.SingleValue);
+            app.Option("--torrcfile", "Path to torrc file containing hidden services directories (default: empty)", CommandOptionType.SingleValue);
+            app.Option("--socksendpoint", "Socks endpoint to connect to onion urls (default: empty)", CommandOptionType.SingleValue);
             app.Option("--debuglog", "A rolling log file for debug messages.", CommandOptionType.SingleValue);
             app.Option("--debugloglevel", "The severity you log (default:information)", CommandOptionType.SingleValue);
             app.Option("--disable-registration", "Disables new user registrations (default:true)", CommandOptionType.SingleValue);

BTCPayServer/Configuration/External/ExternalCharge.cs

@@ -1,19 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Lightning;
-
-namespace BTCPayServer.Configuration.External
-{
-    public class ExternalCharge : ExternalService
-    {
-        public ExternalCharge(LightningConnectionString connectionString)
-        {
-            if (connectionString == null)
-                throw new ArgumentNullException(nameof(connectionString));
-            ConnectionString = connectionString;
-        }
-        public LightningConnectionString ConnectionString { get; }
-    }
-}

BTCPayServer/Configuration/External/ExternalLnd.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Lightning;
-
-namespace BTCPayServer.Configuration.External
-{
-    public abstract class ExternalLnd : ExternalService
-    {
-        public ExternalLnd(LightningConnectionString connectionString, string type)
-        {
-            ConnectionString = connectionString;
-            Type = type;
-        }
-
-        public string Type { get; set; }
-        public LightningConnectionString ConnectionString { get; set; }
-    }
-
-    public class ExternalLndGrpc : ExternalLnd
-    {
-        public ExternalLndGrpc(LightningConnectionString connectionString) : base(connectionString, "lnd-grpc") { }
-    }
-
-    public class ExternalLndRest : ExternalLnd
-    {
-        public ExternalLndRest(LightningConnectionString connectionString) : base(connectionString, "lnd-rest") { }
-    }
-}

BTCPayServer/Configuration/External/ExternalService.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Lightning;
-
-namespace BTCPayServer.Configuration.External
-{
-    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
-    {
-    }
-}

BTCPayServer/Configuration/External/ExternalSpark.cs

@@ -1,19 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Configuration.External
-{
-    public class ExternalSpark : ExternalService
-    {
-        public SparkConnectionString ConnectionString { get; }
-
-        public ExternalSpark(SparkConnectionString connectionString)
-        {
-            if (connectionString == null)
-                throw new ArgumentNullException(nameof(connectionString));
-            ConnectionString = connectionString;
-        }
-    }
-}

BTCPayServer/Configuration/ExternalConnectionString.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+
+namespace BTCPayServer.Configuration
+{
+    public class ExternalConnectionString
+    {
+        public Uri Server { get; set; }
+        public byte[] Macaroon { get; set; }
+        public Macaroons Macaroons { get; set; }
+        public string MacaroonFilePath { get; set; }
+        public string CertificateThumbprint { get; set; }
+        public string MacaroonDirectoryPath { get; set; }
+        public string APIToken { get; set; }
+        public string CookieFilePath { get; set; }
+        public string AccessKey { get; set; }
+
+        /// <summary>
+        /// Return a connectionString which does not depends on external resources or information like relative path or file path
+        /// </summary>
+        /// <returns></returns>
+        public async Task<ExternalConnectionString> Expand(Uri absoluteUrlBase, ExternalServiceTypes serviceType)
+        {
+            var connectionString = this.Clone();
+            // Transform relative URI into absolute URI
+            var serviceUri = connectionString.Server.IsAbsoluteUri ? connectionString.Server : ToRelative(absoluteUrlBase, connectionString.Server.ToString());
+            if (!serviceUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase) &&
+               !serviceUri.DnsSafeHost.EndsWith(".onion", StringComparison.OrdinalIgnoreCase))
+            {
+                throw new System.Security.SecurityException($"Insecure transport protocol to access this service, please use HTTPS or TOR");
+            }
+            connectionString.Server = serviceUri;
+
+            if (serviceType == ExternalServiceTypes.LNDGRPC || serviceType == ExternalServiceTypes.LNDRest)
+            {
+                // Read the MacaroonDirectory
+                if (connectionString.MacaroonDirectoryPath != null)
+                {
+                    try
+                    {
+                        connectionString.Macaroons = await Macaroons.GetFromDirectoryAsync(connectionString.MacaroonDirectoryPath);
+                        connectionString.MacaroonDirectoryPath = null;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new System.IO.DirectoryNotFoundException("Macaroon directory path not found", ex);
+                    }
+                }
+
+                // Read the MacaroonFilePath
+                if (connectionString.MacaroonFilePath != null)
+                {
+                    try
+                    {
+                        connectionString.Macaroon = await System.IO.File.ReadAllBytesAsync(connectionString.MacaroonFilePath);
+                        connectionString.MacaroonFilePath = null;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new System.IO.FileNotFoundException("Macaroon not found", ex);
+                    }
+                }
+            }
+
+            if (serviceType == ExternalServiceTypes.Charge || serviceType == ExternalServiceTypes.RTL || serviceType == ExternalServiceTypes.Spark)
+            {
+                // Read access key from cookie file
+                if (connectionString.CookieFilePath != null)
+                {
+                    string cookieFileContent = null;
+                    bool isFake = false;
+                    try
+                    {
+                        cookieFileContent = await System.IO.File.ReadAllTextAsync(connectionString.CookieFilePath);
+                        isFake = connectionString.CookieFilePath == "fake";
+                        connectionString.CookieFilePath = null;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new System.IO.FileNotFoundException("Cookie file path not found", ex);
+                    }
+                    if (serviceType == ExternalServiceTypes.RTL)
+                    {
+                        connectionString.AccessKey = cookieFileContent;
+                    }
+                    else if (serviceType == ExternalServiceTypes.Spark)
+                    {
+                        var cookie = (isFake ? "fake:fake:fake" // Hacks for testing
+                                    : cookieFileContent).Split(':');
+                        if (cookie.Length >= 3)
+                        {
+                            connectionString.AccessKey = cookie[2];
+                        }
+                        else
+                        {
+                            throw new FormatException("Invalid cookiefile format");
+                        }
+                    }
+                    else if (serviceType == ExternalServiceTypes.Charge)
+                    {
+                        connectionString.APIToken = isFake ? "fake" : cookieFileContent;
+                    }
+                }
+            }
+            return connectionString;
+        }
+
+        private Uri ToRelative(Uri absoluteUrlBase, string path)
+        {
+            if (path.StartsWith('/'))
+                path = path.Substring(1);
+            return new Uri($"{absoluteUrlBase.AbsoluteUri.WithTrailingSlash()}{path}", UriKind.Absolute);
+        }
+
+        public ExternalConnectionString Clone()
+        {
+            return new ExternalConnectionString()
+            {
+                MacaroonFilePath = MacaroonFilePath,
+                CertificateThumbprint = CertificateThumbprint,
+                Macaroon = Macaroon,
+                MacaroonDirectoryPath = MacaroonDirectoryPath,
+                Server = Server,
+                APIToken = APIToken,
+                CookieFilePath = CookieFilePath,
+                AccessKey = AccessKey,
+                Macaroons = Macaroons?.Clone()
+            };
+        }
+        public static bool TryParse(string str, out ExternalConnectionString result, out string error)
+        {
+            if (str == null)
+                throw new ArgumentNullException(nameof(str));
+            error = null;
+            result = null;
+            var resultTemp = new ExternalConnectionString();
+            foreach(var kv in str.Split(';')
+                        .Select(part => part.Split('='))
+                        .Where(kv => kv.Length == 2))
+            {
+                switch (kv[0].ToLowerInvariant())
+                {
+                    case "server":
+                        if (resultTemp.Server != null)
+                        {
+                            error = "Duplicated server attribute";
+                            return false;
+                        }
+                        if (!Uri.IsWellFormedUriString(kv[1], UriKind.RelativeOrAbsolute))
+                        {
+                            error = "Invalid URI";
+                            return false;
+                        }
+                        resultTemp.Server = new Uri(kv[1], UriKind.RelativeOrAbsolute);
+                        if (!resultTemp.Server.IsAbsoluteUri && (kv[1].Length == 0 || kv[1][0] != '/'))
+                            resultTemp.Server = new Uri($"/{kv[1]}", UriKind.RelativeOrAbsolute);
+                        break;
+                    case "cookiefile":
+                    case "cookiefilepath":
+                        if (resultTemp.CookieFilePath != null)
+                        {
+                            error = "Duplicated cookiefile attribute";
+                            return false;
+                        }
+                            
+                        resultTemp.CookieFilePath = kv[1];
+                        break;
+                    case "macaroondirectorypath":
+                        resultTemp.MacaroonDirectoryPath = kv[1];
+                        break;
+                    case "certthumbprint":
+                        resultTemp.CertificateThumbprint = kv[1];
+                        break;
+                    case "macaroonfilepath":
+                        resultTemp.MacaroonFilePath = kv[1];
+                        break;
+                    case "api-token":
+                        resultTemp.APIToken = kv[1];
+                        break;
+                    case "access-key":
+                        resultTemp.AccessKey = kv[1];
+                        break;
+                }
+            }
+            result = resultTemp;
+            return true;
+        }
+    }
+}

BTCPayServer/Configuration/ExternalService.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Lightning;
+using Microsoft.Extensions.Configuration;
+
+namespace BTCPayServer.Configuration
+{
+    public class ExternalServices : List<ExternalService>
+    {
+        public void Load(string cryptoCode, IConfiguration configuration)
+        {
+            Load(configuration, cryptoCode, "lndgrpc", ExternalServiceTypes.LNDGRPC, "Invalid setting {0}, " + Environment.NewLine +
+                                "lnd server: 'server=https://lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                "lnd server: 'server=https://lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                "lnd server: 'server=https://lnd.example.com;macaroondirectorypath=/root/.lnd;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                "Error: {1}",
+                                "LND (gRPC server)");
+            Load(configuration, cryptoCode, "lndrest", ExternalServiceTypes.LNDRest, "Invalid setting {0}, " + Environment.NewLine +
+                                "lnd server: 'server=https://lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                "lnd server: 'server=https://lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                "lnd server: 'server=https://lnd.example.com;macaroondirectorypath=/root/.lnd;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                "Error: {1}",
+                                "LND (REST server)");
+            Load(configuration, cryptoCode, "spark", ExternalServiceTypes.Spark, "Invalid setting {0}, " + Environment.NewLine +
+                                $"Valid example: 'server=https://btcpay.example.com/spark/btc/;cookiefile=/etc/clightning_bitcoin_spark/.cookie'" + Environment.NewLine +
+                                "Error: {1}",
+                                "C-Lightning (Spark server)");
+            Load(configuration, cryptoCode, "rtl", ExternalServiceTypes.RTL, "Invalid setting {0}, " + Environment.NewLine +
+                                $"Valid example: 'server=https://btcpay.example.com/rtl/btc/;cookiefile=/etc/clightning_bitcoin_rtl/.cookie'" + Environment.NewLine +
+                                "Error: {1}",
+                                "LND (Ride the Lightning server)");
+            Load(configuration, cryptoCode, "charge", ExternalServiceTypes.Charge, "Invalid setting {0}, " + Environment.NewLine +
+                                $"lightning charge server: 'type=charge;server=https://charge.example.com;api-token=2abdf302...'" + Environment.NewLine +
+                                $"lightning charge server: 'type=charge;server=https://charge.example.com;cookiefilepath=/root/.charge/.cookie'" + Environment.NewLine +
+                                "Error: {1}",
+                                "C-Lightning (Charge server)");
+        }
+
+        void Load(IConfiguration configuration, string cryptoCode, string serviceName, ExternalServiceTypes type, string errorMessage, string displayName)
+        {
+            var setting = $"{cryptoCode}.external.{serviceName}";
+            var connStr = configuration.GetOrDefault<string>(setting, string.Empty);
+            if (connStr.Length != 0)
+            {
+                if (!ExternalConnectionString.TryParse(connStr, out var connectionString, out var error))
+                {
+                    throw new ConfigException(string.Format(CultureInfo.InvariantCulture, errorMessage, setting, error));
+                }
+                this.Add(new ExternalService() { Type = type, ConnectionString = connectionString, CryptoCode = cryptoCode, DisplayName = displayName, ServiceName = serviceName });
+            }
+        }
+
+        public ExternalService GetService(string serviceName, string cryptoCode)
+        {
+            return this.FirstOrDefault(o => o.CryptoCode.Equals(cryptoCode, StringComparison.OrdinalIgnoreCase) &&
+                                                                                    o.ServiceName.Equals(serviceName, StringComparison.OrdinalIgnoreCase));
+        }
+    }
+
+    public class ExternalService
+    {
+        public string DisplayName { get; set; }
+        public ExternalServiceTypes Type { get; set; }
+        public ExternalConnectionString ConnectionString { get; set; }
+        public string CryptoCode { get; set; }
+        public string ServiceName { get; set; }
+    }
+
+    public enum ExternalServiceTypes
+    {
+        LNDRest,
+        LNDGRPC,
+        Spark,
+        RTL,
+        Charge
+    }
+}

BTCPayServer/Configuration/SparkConnectionString.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Configuration
-{
-    public class SparkConnectionString
-    {
-        public Uri Server { get; private set; }
-        public string CookeFile { get; private set; }
-
-        public static bool TryParse(string str, out SparkConnectionString result)
-        {
-            if (str == null)
-                throw new ArgumentNullException(nameof(str));
-
-            result = null;
-            var resultTemp = new SparkConnectionString();
-            foreach(var kv in str.Split(';')
-                        .Select(part => part.Split('='))
-                        .Where(kv => kv.Length == 2))
-            {
-                switch (kv[0].ToLowerInvariant())
-                {
-                    case "server":
-                        if (resultTemp.Server != null)
-                            return false;
-                        if (!Uri.IsWellFormedUriString(kv[1], UriKind.Absolute))
-                            return false;
-                        resultTemp.Server = new Uri(kv[1], UriKind.Absolute);
-                        break;
-                    case "cookiefile":
-                    case "cookiefilepath":
-                        if (resultTemp.CookeFile != null)
-                            return false;
-                        resultTemp.CookeFile = kv[1];
-                        break;
-                    default:
-                        return false;
-                }
-            }
-            result = resultTemp;
-            return true;
-        }
-    }
-}

BTCPayServer/Controllers/AccessTokenController.cs

@@ -14,8 +14,7 @@ using System.Threading.Tasks;
 namespace BTCPayServer.Controllers
 {
     [Authorize(AuthenticationSchemes = Security.Policies.BitpayAuthentication)]
-    [BitpayAPIConstraint(true)]
-    [EnableCors(CorsPolicies.All)]
+    [BitpayAPIConstraint()]
     public class AccessTokenController : Controller
     {
         TokenRepository _TokenRepository;
@@ -36,20 +35,19 @@ namespace BTCPayServer.Controllers
         [AllowAnonymous]
         public async Task<DataWrapper<List<PairingCodeResponse>>> Tokens([FromBody] TokenRequest request)
         {
+            if (request == null)
+                throw new BitpayHttpException(400, "The request body is missing");
             PairingCodeEntity pairingEntity = null;
             if (string.IsNullOrEmpty(request.PairingCode))
             {
                 if (string.IsNullOrEmpty(request.Id) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(request.Id))
                     throw new BitpayHttpException(400, "'id' property is required");
-                if (string.IsNullOrEmpty(request.Facade))
-                    throw new BitpayHttpException(400, "'facade' property is required");
 
                 var pairingCode = await _TokenRepository.CreatePairingCodeAsync();
                 await _TokenRepository.PairWithSINAsync(pairingCode, request.Id);
                 pairingEntity = await _TokenRepository.UpdatePairingCode(new PairingCodeEntity()
                 {
                     Id = pairingCode,
-                    Facade = request.Facade,
                     Label = request.Label
                 });
 
@@ -85,7 +83,7 @@ namespace BTCPayServer.Controllers
                         PairingCode = pairingEntity.Id,
                         PairingExpiration = pairingEntity.Expiration,
                         DateCreated = pairingEntity.CreatedTime,
-                        Facade = pairingEntity.Facade,
+                        Facade = "merchant",
                         Token = pairingEntity.TokenValue,
                         Label = pairingEntity.Label
                     }

BTCPayServer/Controllers/AppsController.Crowdfund.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Text;
 using System.Text.Encodings.Web;
 using System.Threading.Tasks;
@@ -10,42 +11,15 @@ namespace BTCPayServer.Controllers
 {
     public partial class AppsController
     {
-        public class CrowdfundAppUpdated
+        public class AppUpdated
         {
             public string AppId { get; set; }
-            public CrowdfundSettings Settings { get; set; }
+            public object Settings { get; set; }
             public string StoreId { get; set; }
-        }
-        
-        public class CrowdfundSettings
-        {
-            public string Title { get; set; }
-            public string Description { get; set; }
-            public bool Enabled { get; set; } = false;
-        
-            public DateTime? StartDate { get; set; }
-            public DateTime? EndDate { get; set; }
-        
-            public string TargetCurrency { get; set; }
-            public decimal? TargetAmount { get; set; }
-        
-            public bool EnforceTargetAmount { get; set; }
-            public string CustomCSSLink { get; set; }
-            public string MainImageUrl { get; set; }
-            public string NotificationUrl { get; set; }
-            public string Tagline { get; set; }
-            public string EmbeddedCSS { get; set; }
-            public string PerksTemplate { get; set; }
-            public bool DisqusEnabled { get; set; }= false;
-            public bool SoundsEnabled { get; set; }= true;
-            public string DisqusShortname { get; set; }
-            public bool AnimationsEnabled { get; set; } = true;
-            public bool UseInvoiceAmount { get; set; } = true;
-            public int ResetEveryAmount { get; set; } = 1;
-            public CrowdfundResetEvery ResetEvery { get; set; } = CrowdfundResetEvery.Never;
-            public bool UseAllStoreInvoices { get; set; }
-            public bool DisplayPerksRanking { get; set; }
-            public bool SortPerksByPopularity { get; set; }
+            public override string ToString()
+            {
+                return String.Empty;
+            }
         }
         
         
@@ -77,13 +51,15 @@ namespace BTCPayServer.Controllers
                 SoundsEnabled = settings.SoundsEnabled,
                 DisqusShortname = settings.DisqusShortname,
                 AnimationsEnabled = settings.AnimationsEnabled,
-                UseInvoiceAmount = settings.UseInvoiceAmount,
                 ResetEveryAmount = settings.ResetEveryAmount,
                 ResetEvery = Enum.GetName(typeof(CrowdfundResetEvery), settings.ResetEvery),
-                UseAllStoreInvoices = settings.UseAllStoreInvoices,
+                UseAllStoreInvoices = app.TagAllInvoices,
                 AppId = appId,
+                SearchTerm = app.TagAllInvoices ? $"storeid:{app.StoreDataId}" : $"orderid:{AppService.GetCrowdfundOrderId(appId)}",
                 DisplayPerksRanking = settings.DisplayPerksRanking,
-                SortPerksByPopularity = settings.SortPerksByPopularity
+                SortPerksByPopularity = settings.SortPerksByPopularity,
+                Sounds                = string.Join(Environment.NewLine, settings.Sounds),
+                AnimationColors                = string.Join(Environment.NewLine, settings.AnimationColors)
             };
             return View(vm);
         }
@@ -91,12 +67,12 @@ namespace BTCPayServer.Controllers
         [Route("{appId}/settings/crowdfund")]
         public async Task<IActionResult> UpdateCrowdfund(string appId, UpdateCrowdfundViewModel vm)
         {
-            if (!string.IsNullOrEmpty( vm.TargetCurrency) && _AppsHelper.GetCurrencyData(vm.TargetCurrency, false) == null)
+            if (!string.IsNullOrEmpty( vm.TargetCurrency) && _currencies.GetCurrencyData(vm.TargetCurrency, false) == null)
                 ModelState.AddModelError(nameof(vm.TargetCurrency), "Invalid currency");
           
             try
             {
-                _AppsHelper.Parse(vm.PerksTemplate, vm.TargetCurrency).ToString();
+                _AppService.Parse(vm.PerksTemplate, vm.TargetCurrency).ToString();
             }
             catch
             {
@@ -117,6 +93,24 @@ namespace BTCPayServer.Controllers
             {
                 ModelState.AddModelError(nameof(vm.DisplayPerksRanking), "You must sort by popularity in order to display ranking.");
             }
+
+            var parsedSounds = vm.Sounds.Split(
+                new[] {"\r\n", "\r", "\n"},
+                StringSplitOptions.None
+            ).Select(s => s.Trim()).ToArray();
+            if (vm.SoundsEnabled && !parsedSounds.Any())
+            {
+                ModelState.AddModelError(nameof(vm.Sounds), "You must have at least one sound if you enable sounds");
+            }
+            
+            var parsedAnimationColors = vm.AnimationColors.Split(
+                new[] { "\r\n", "\r", "\n" },
+                StringSplitOptions.None
+            ).Select(s => s.Trim()).ToArray();
+            if (vm.AnimationsEnabled && !parsedAnimationColors.Any())
+            {
+                ModelState.AddModelError(nameof(vm.AnimationColors), "You must have at least one animation color if you enable animations");
+            }
             
             if (!ModelState.IsValid)
             {
@@ -135,13 +129,14 @@ namespace BTCPayServer.Controllers
                 EnforceTargetAmount = vm.EnforceTargetAmount,
                 StartDate = vm.StartDate,
                 TargetCurrency = vm.TargetCurrency,
-                Description = _AppsHelper.Sanitize( vm.Description),
+                Description = _htmlSanitizer.Sanitize( vm.Description),
                 EndDate = vm.EndDate,
                 TargetAmount = vm.TargetAmount,
                 CustomCSSLink = vm.CustomCSSLink,
                 MainImageUrl = vm.MainImageUrl,
                 EmbeddedCSS = vm.EmbeddedCSS,
                 NotificationUrl = vm.NotificationUrl,
+                NotificationEmail = vm.NotificationEmail,
                 Tagline = vm.Tagline,
                 PerksTemplate = vm.PerksTemplate,
                 DisqusEnabled = vm.DisqusEnabled,
@@ -150,15 +145,17 @@ namespace BTCPayServer.Controllers
                 AnimationsEnabled = vm.AnimationsEnabled,
                 ResetEveryAmount = vm.ResetEveryAmount,
                 ResetEvery = Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery),
-                UseInvoiceAmount = vm.UseInvoiceAmount,
-                UseAllStoreInvoices = vm.UseAllStoreInvoices,
                 DisplayPerksRanking = vm.DisplayPerksRanking,
-                SortPerksByPopularity = vm.SortPerksByPopularity
+                SortPerksByPopularity = vm.SortPerksByPopularity,
+                Sounds = parsedSounds,
+                AnimationColors = parsedAnimationColors
             };
-            
+
+            app.TagAllInvoices = vm.UseAllStoreInvoices;
             app.SetSettings(newSettings);
             await UpdateAppSettings(app);
-            _EventAggregator.Publish(new CrowdfundAppUpdated()
+
+            _EventAggregator.Publish(new AppUpdated()
             {
                 AppId = appId,
                 StoreId = app.StoreDataId,

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -55,12 +55,16 @@ namespace BTCPayServer.Controllers
                     "  custom: true";
                 EnableShoppingCart = false;
                 ShowCustomAmount = true;
+                ShowDiscount = true;
+                EnableTips = true;
             }
             public string Title { get; set; }
             public string Currency { get; set; }
             public string Template { get; set; }
             public bool EnableShoppingCart { get; set; }
             public bool ShowCustomAmount { get; set; }
+            public bool ShowDiscount { get; set; }
+            public bool EnableTips { get; set; }
 
             public const string BUTTON_TEXT_DEF = "Buy for {0}";
             public string ButtonText { get; set; } = BUTTON_TEXT_DEF;
@@ -73,6 +77,9 @@ namespace BTCPayServer.Controllers
 
 
             public string CustomCSSLink { get; set; }
+            public string NotificationEmail { get; set; }
+            public string NotificationUrl { get; set; }
+            public bool? RedirectAutomatically { get; set; }
         }
 
         [HttpGet]
@@ -89,13 +96,18 @@ namespace BTCPayServer.Controllers
                 Title = settings.Title,
                 EnableShoppingCart = settings.EnableShoppingCart,
                 ShowCustomAmount = settings.ShowCustomAmount,
+                ShowDiscount = settings.ShowDiscount,
+                EnableTips = settings.EnableTips,
                 Currency = settings.Currency,
                 Template = settings.Template,
                 ButtonText = settings.ButtonText ?? PointOfSaleSettings.BUTTON_TEXT_DEF,
                 CustomButtonText = settings.CustomButtonText ?? PointOfSaleSettings.CUSTOM_BUTTON_TEXT_DEF,
                 CustomTipText = settings.CustomTipText ?? PointOfSaleSettings.CUSTOM_TIP_TEXT_DEF,
                 CustomTipPercentages = settings.CustomTipPercentages != null ? string.Join(",", settings.CustomTipPercentages) : string.Join(",", PointOfSaleSettings.CUSTOM_TIP_PERCENTAGES_DEF),
-                CustomCSSLink = settings.CustomCSSLink
+                CustomCSSLink = settings.CustomCSSLink,
+                NotificationEmail = settings.NotificationEmail,
+                NotificationUrl = settings.NotificationUrl,
+                RedirectAutomatically = settings.RedirectAutomatically.HasValue? settings.RedirectAutomatically.Value? "true": "false" : "" 
             };
             if (HttpContext?.Request != null)
             {
@@ -116,7 +128,7 @@ namespace BTCPayServer.Controllers
                 }
                 try
                 {
-                    var items = _AppsHelper.Parse(settings.Template, settings.Currency);
+                    var items = _AppService.Parse(settings.Template, settings.Currency);
                     var builder = new StringBuilder();
                     builder.AppendLine($"<form method=\"POST\" action=\"{encoder.Encode(appUrl)}\">");
                     builder.AppendLine($"  <input type=\"hidden\" name=\"email\" value=\"customer@example.com\" />");
@@ -138,11 +150,11 @@ namespace BTCPayServer.Controllers
         [Route("{appId}/settings/pos")]
         public async Task<IActionResult> UpdatePointOfSale(string appId, UpdatePointOfSaleViewModel vm)
         {
-            if (_AppsHelper.GetCurrencyData(vm.Currency, false) == null)
+            if (_currencies.GetCurrencyData(vm.Currency, false) == null)
                 ModelState.AddModelError(nameof(vm.Currency), "Invalid currency");
             try
             {
-                _AppsHelper.Parse(vm.Template, vm.Currency);
+                _AppService.Parse(vm.Template, vm.Currency);
             }
             catch
             {
@@ -160,13 +172,19 @@ namespace BTCPayServer.Controllers
                 Title = vm.Title,
                 EnableShoppingCart = vm.EnableShoppingCart,
                 ShowCustomAmount = vm.ShowCustomAmount,
+                ShowDiscount = vm.ShowDiscount,
+                EnableTips = vm.EnableTips,
                 Currency = vm.Currency.ToUpperInvariant(),
                 Template = vm.Template,
                 ButtonText = vm.ButtonText,
                 CustomButtonText = vm.CustomButtonText,
                 CustomTipText = vm.CustomTipText,
                 CustomTipPercentages = ListSplit(vm.CustomTipPercentages),
-                CustomCSSLink = vm.CustomCSSLink
+                CustomCSSLink = vm.CustomCSSLink,
+                NotificationUrl = vm.NotificationUrl,
+                NotificationEmail = vm.NotificationEmail,
+                RedirectAutomatically = string.IsNullOrEmpty(vm.RedirectAutomatically)? (bool?) null: bool.Parse(vm.RedirectAutomatically)
+                
             });
             await UpdateAppSettings(app);
             StatusMessage = "App updated";
@@ -180,6 +198,7 @@ namespace BTCPayServer.Controllers
                 ctx.Apps.Add(app);
                 ctx.Entry<AppData>(app).State = EntityState.Modified;
                 ctx.Entry<AppData>(app).Property(a => a.Settings).IsModified = true;
+                ctx.Entry<AppData>(app).Property(a => a.TagAllInvoices).IsModified = true;
                 await ctx.SaveChangesAsync();
             }
         }

BTCPayServer/Controllers/AppsController.cs

@@ -7,6 +7,8 @@ using BTCPayServer.Models;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Security;
 using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Rates;
+using Ganss.XSS;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
@@ -26,20 +28,26 @@ namespace BTCPayServer.Controllers
             ApplicationDbContextFactory contextFactory,
             EventAggregator eventAggregator,
             BTCPayNetworkProvider networkProvider,
-            AppsHelper appsHelper)
+            CurrencyNameTable currencies,
+            HtmlSanitizer htmlSanitizer,
+            AppService AppService)
         {
             _UserManager = userManager;
             _ContextFactory = contextFactory;
             _EventAggregator = eventAggregator;
             _NetworkProvider = networkProvider;
-            _AppsHelper = appsHelper;
+            _currencies = currencies;
+            _htmlSanitizer = htmlSanitizer;
+            _AppService = AppService;
         }
 
         private UserManager<ApplicationUser> _UserManager;
         private ApplicationDbContextFactory _ContextFactory;
         private readonly EventAggregator _EventAggregator;
         private BTCPayNetworkProvider _NetworkProvider;
-        private AppsHelper _AppsHelper;
+        private readonly CurrencyNameTable _currencies;
+        private readonly HtmlSanitizer _htmlSanitizer;
+        private AppService _AppService;
 
         [TempData]
         public string StatusMessage { get; set; }
@@ -47,7 +55,7 @@ namespace BTCPayServer.Controllers
 
         public async Task<IActionResult> ListApps()
         {
-            var apps = await _AppsHelper.GetAllApps(GetUserId());
+            var apps = await _AppService.GetAllApps(GetUserId());
             return View(new ListAppsViewModel()
             {
                 Apps = apps
@@ -61,7 +69,7 @@ namespace BTCPayServer.Controllers
             var appData = await GetOwnedApp(appId);
             if (appData == null)
                 return NotFound();
-            if (await _AppsHelper.DeleteApp(appData))
+            if (await _AppService.DeleteApp(appData))
                 StatusMessage = "App removed successfully";
             return RedirectToAction(nameof(ListApps));
         }
@@ -70,13 +78,13 @@ namespace BTCPayServer.Controllers
         [Route("create")]
         public async Task<IActionResult> CreateApp()
         {
-            var stores = await _AppsHelper.GetOwnedStores(GetUserId());
+            var stores = await _AppService.GetOwnedStores(GetUserId());
             if (stores.Length == 0)
             {
                 StatusMessage = new StatusMessageModel()
                 {
                     Html =
-                        $"Error: You must have created at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
+                        $"Error: You need to create at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
                     Severity = StatusMessageModel.StatusSeverity.Error
                 }.ToString();
                 return RedirectToAction(nameof(ListApps));
@@ -90,13 +98,13 @@ namespace BTCPayServer.Controllers
         [Route("create")]
         public async Task<IActionResult> CreateApp(CreateAppViewModel vm)
         {
-            var stores = await _AppsHelper.GetOwnedStores(GetUserId());
+            var stores = await _AppService.GetOwnedStores(GetUserId());
             if (stores.Length == 0)
             {
                 StatusMessage = new StatusMessageModel()
                 {
                     Html =
-                        $"Error: You must have created at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
+                        $"Error: You need to create at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
                     Severity = StatusMessageModel.StatusSeverity.Error
                 }.ToString();
                 return RedirectToAction(nameof(ListApps));
@@ -160,7 +168,7 @@ namespace BTCPayServer.Controllers
 
         private Task<AppData> GetOwnedApp(string appId, AppType? type = null)
         {
-            return _AppsHelper.GetAppDataIfOwner(GetUserId(), appId, type);
+            return _AppService.GetAppDataIfOwner(GetUserId(), appId, type);
         }
 
         

BTCPayServer/Controllers/AppsPublicController.cs

@@ -5,27 +5,26 @@ using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Security.Claims;
+using System.Threading;
 using System.Threading.Tasks;
-using BTCPayServer.Crowdfund;
 using BTCPayServer.Data;
 using BTCPayServer.Filters;
-using BTCPayServer.Hubs;
+using BTCPayServer.ModelBinders;
 using BTCPayServer.Models;
 using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Payments;
 using BTCPayServer.Rating;
 using BTCPayServer.Security;
 using BTCPayServer.Services.Apps;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
 using Ganss.XSS;
-using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using NBitpayClient;
-using Newtonsoft.Json.Linq;
 using YamlDotNet.RepresentationModel;
 using static BTCPayServer.Controllers.AppsController;
 
@@ -33,19 +32,17 @@ namespace BTCPayServer.Controllers
 {
     public class AppsPublicController : Controller
     {
-        public AppsPublicController(AppsHelper appsHelper, 
-            InvoiceController invoiceController, 
-            CrowdfundHubStreamer crowdfundHubStreamer, UserManager<ApplicationUser> userManager)
+        public AppsPublicController(AppService AppService,
+            InvoiceController invoiceController,
+            UserManager<ApplicationUser> userManager)
         {
-            _AppsHelper = appsHelper;
+            _AppService = AppService;
             _InvoiceController = invoiceController;
-            _CrowdfundHubStreamer = crowdfundHubStreamer;
             _UserManager = userManager;
         }
 
-        private AppsHelper _AppsHelper;
+        private AppService _AppService;
         private InvoiceController _InvoiceController;
-        private readonly CrowdfundHubStreamer _CrowdfundHubStreamer;
         private readonly UserManager<ApplicationUser> _UserManager;
 
         [HttpGet]
@@ -53,12 +50,12 @@ namespace BTCPayServer.Controllers
         [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
         public async Task<IActionResult> ViewPointOfSale(string appId)
         {
-            var app = await _AppsHelper.GetApp(appId, AppType.PointOfSale);
+            var app = await _AppService.GetApp(appId, AppType.PointOfSale);
             if (app == null)
                 return NotFound();
             var settings = app.GetSettings<PointOfSaleSettings>();
 
-            var numberFormatInfo = _AppsHelper.Currencies.GetNumberFormatInfo(settings.Currency) ?? _AppsHelper.Currencies.GetNumberFormatInfo("USD");
+            var numberFormatInfo = _AppService.Currencies.GetNumberFormatInfo(settings.Currency) ?? _AppService.Currencies.GetNumberFormatInfo("USD");
             double step = Math.Pow(10, -(numberFormatInfo.CurrencyDecimalDigits));
 
             return View(new ViewPointOfSaleViewModel()
@@ -67,6 +64,8 @@ namespace BTCPayServer.Controllers
                 Step = step.ToString(CultureInfo.InvariantCulture),
                 EnableShoppingCart = settings.EnableShoppingCart,
                 ShowCustomAmount = settings.ShowCustomAmount,
+                ShowDiscount = settings.ShowDiscount,
+                EnableTips = settings.EnableTips,
                 CurrencyCode = settings.Currency,
                 CurrencySymbol = numberFormatInfo.CurrencySymbol,
                 CurrencyInfo = new ViewPointOfSaleViewModel.CurrencyInfoData()
@@ -78,7 +77,7 @@ namespace BTCPayServer.Controllers
                     Prefixed = new[] { 0, 2 }.Contains(numberFormatInfo.CurrencyPositivePattern),
                     SymbolSpace = new[] { 2, 3 }.Contains(numberFormatInfo.CurrencyPositivePattern)
                 },
-                Items = _AppsHelper.Parse(settings.Template, settings.Currency),
+                Items = _AppService.Parse(settings.Template, settings.Currency),
                 ButtonText = settings.ButtonText,
                 CustomButtonText = settings.CustomButtonText,
                 CustomTipText = settings.CustomTipText,
@@ -87,35 +86,37 @@ namespace BTCPayServer.Controllers
                 AppId = appId
             });
         }
-        
-        
+
+
         [HttpGet]
         [Route("/apps/{appId}/crowdfund")]
         [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
         public async Task<IActionResult> ViewCrowdfund(string appId, string statusMessage)
-        
         {
-            var app = await _AppsHelper.GetApp(appId, AppType.Crowdfund, true);
-            
+            var app = await _AppService.GetApp(appId, AppType.Crowdfund, true);
+
             if (app == null)
                 return NotFound();
             var settings = app.GetSettings<CrowdfundSettings>();
-            
-            var isAdmin = await _AppsHelper.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
-            
-            var hasEnoughSettingsToLoad = !string.IsNullOrEmpty(settings.TargetCurrency );
+
+            var isAdmin = await _AppService.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
+
+            var hasEnoughSettingsToLoad = !string.IsNullOrEmpty(settings.TargetCurrency);
             if (!hasEnoughSettingsToLoad)
             {
-                if(!isAdmin)
+                if (!isAdmin)
                     return NotFound();
 
                 return NotFound("A Target Currency must be set for this app in order to be loadable.");
             }
-            if (settings.Enabled) return View(await _CrowdfundHubStreamer.GetCrowdfundInfo(appId));
-            if(!isAdmin)
+            var appInfo = (ViewCrowdfundViewModel)(await _AppService.GetAppInfo(appId));
+            appInfo.HubPath = AppHub.GetHubPath(this.Request);
+            if (settings.Enabled)
+                return View(appInfo);
+            if (!isAdmin)
                 return NotFound();
 
-            return View(await _CrowdfundHubStreamer.GetCrowdfundInfo(appId));
+            return View(appInfo);
         }
 
         [HttpPost]
@@ -123,43 +124,41 @@ namespace BTCPayServer.Controllers
         [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
         [IgnoreAntiforgeryToken]
         [EnableCors(CorsPolicies.All)]
-        public async Task<IActionResult> ContributeToCrowdfund(string appId, ContributeToCrowdfund request)
+        public async Task<IActionResult> ContributeToCrowdfund(string appId, ContributeToCrowdfund request, CancellationToken cancellationToken)
         {
-            var app = await _AppsHelper.GetApp(appId, AppType.Crowdfund, true);
-            
+            var app = await _AppService.GetApp(appId, AppType.Crowdfund, true);
+
             if (app == null)
                 return NotFound();
             var settings = app.GetSettings<CrowdfundSettings>();
-            
-           
-            var isAdmin = await _AppsHelper.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
- 
-            if (!settings.Enabled)
-            {
-                if(!isAdmin)
-                    return NotFound("Crowdfund is not currently active");
-            }
 
-            var info = await _CrowdfundHubStreamer.GetCrowdfundInfo(appId);
-            
-            if(!isAdmin && 
-               
-               ((settings.StartDate.HasValue && DateTime.Now  < settings.StartDate) || 
-                (settings.EndDate.HasValue && DateTime.Now  > settings.EndDate) || 
-                (settings.EnforceTargetAmount && 
-                    (info.Info.PendingProgressPercentage.GetValueOrDefault(0) + 
-                     info.Info.ProgressPercentage.GetValueOrDefault(0)) >= 100)))
+
+            var isAdmin = await _AppService.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
+
+            if (!settings.Enabled && !isAdmin)
             {
                 return NotFound("Crowdfund is not currently active");
             }
 
-            var store = await _AppsHelper.GetStore(app);
-            var title =  settings.Title;
+            var info = (ViewCrowdfundViewModel)await _AppService.GetAppInfo(appId);
+            info.HubPath = AppHub.GetHubPath(this.Request);
+            if (!isAdmin &&
+                ((settings.StartDate.HasValue && DateTime.Now < settings.StartDate) ||
+                 (settings.EndDate.HasValue && DateTime.Now > settings.EndDate) ||
+                 (settings.EnforceTargetAmount &&
+                  (info.Info.PendingProgressPercentage.GetValueOrDefault(0) +
+                   info.Info.ProgressPercentage.GetValueOrDefault(0)) >= 100)))
+            {
+                return NotFound("Crowdfund is not currently active");
+            }
+
+            var store = await _AppService.GetStore(app);
+            var title = settings.Title;
             var price = request.Amount;
             ViewPointOfSaleViewModel.Item choice = null;
             if (!string.IsNullOrEmpty(request.ChoiceKey))
             {
-                var choices = _AppsHelper.Parse(settings.PerksTemplate, settings.TargetCurrency);
+                var choices = _AppService.Parse(settings.PerksTemplate, settings.TargetCurrency);
                 choice = choices.FirstOrDefault(c => c.Id == request.ChoiceKey);
                 if (choice == null)
                     return NotFound("Incorrect option provided");
@@ -170,33 +169,32 @@ namespace BTCPayServer.Controllers
             }
 
             if (!isAdmin && (settings.EnforceTargetAmount && info.TargetAmount.HasValue && price >
-                (info.TargetAmount - (info.Info.CurrentAmount + info.Info.CurrentPendingAmount))))
+                             (info.TargetAmount - (info.Info.CurrentAmount + info.Info.CurrentPendingAmount))))
             {
                 return NotFound("Contribution Amount is more than is currently allowed.");
             }
-            
+
             store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
             try
             {
-                var invoice = await _InvoiceController.CreateInvoiceCore(new Invoice()
+                var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
                 {
-                    OrderId = $"{CrowdfundHubStreamer.CrowdfundInvoiceOrderIdPrefix}{appId}",
+                    OrderId = AppService.GetCrowdfundOrderId(appId),
                     Currency = settings.TargetCurrency,
                     ItemCode = request.ChoiceKey ?? string.Empty,
                     ItemDesc = title,
                     BuyerEmail = request.Email,
                     Price = price,
                     NotificationURL = settings.NotificationUrl,
+                    NotificationEmail = settings.NotificationEmail,
                     FullNotifications = true,
                     ExtendedNotifications = true,
-                    RedirectURL = request.RedirectUrl ?? Request.GetDisplayUrl(),
-                
-                
-                }, store, HttpContext.Request.GetAbsoluteRoot());
+                    RedirectURL = request.RedirectUrl ?? Request.GetDisplayUrl()
+                }, store, HttpContext.Request.GetAbsoluteRoot(), new List<string> { AppService.GetAppInternalTag(appId) }, cancellationToken: cancellationToken);
                 if (request.RedirectToCheckout)
                 {
                     return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice",
-                        new {invoiceId = invoice.Data.Id});
+                        new { invoiceId = invoice.Data.Id });
                 }
                 else
                 {
@@ -207,9 +205,8 @@ namespace BTCPayServer.Controllers
             {
                 return BadRequest(e.Message);
             }
-            
+
         }
-        
 
         [HttpPost]
         [Route("/apps/{appId}/pos")]
@@ -217,15 +214,15 @@ namespace BTCPayServer.Controllers
         [IgnoreAntiforgeryToken]
         [EnableCors(CorsPolicies.All)]
         public async Task<IActionResult> ViewPointOfSale(string appId,
-                                                        decimal amount,
+                                                        [ModelBinder(typeof(InvariantDecimalModelBinder))] decimal amount,
                                                         string email,
                                                         string orderId,
                                                         string notificationUrl,
                                                         string redirectUrl,
                                                         string choiceKey,
-                                                        string posData = null)
+                                                        string posData = null, CancellationToken cancellationToken = default)
         {
-            var app = await _AppsHelper.GetApp(appId, AppType.PointOfSale);
+            var app = await _AppService.GetApp(appId, AppType.PointOfSale);
             if (string.IsNullOrEmpty(choiceKey) && amount <= 0)
             {
                 return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
@@ -242,7 +239,7 @@ namespace BTCPayServer.Controllers
             ViewPointOfSaleViewModel.Item choice = null;
             if (!string.IsNullOrEmpty(choiceKey))
             {
-                var choices = _AppsHelper.Parse(settings.Template, settings.Currency);
+                var choices = _AppService.Parse(settings.Template, settings.Currency);
                 choice = choices.FirstOrDefault(c => c.Id == choiceKey);
                 if (choice == null)
                     return NotFound();
@@ -258,9 +255,9 @@ namespace BTCPayServer.Controllers
                 price = amount;
                 title = settings.Title;
             }
-            var store = await _AppsHelper.GetStore(app);
+            var store = await _AppService.GetStore(app);
             store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
-            var invoice = await _InvoiceController.CreateInvoiceCore(new NBitpayClient.Invoice()
+            var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
             {
                 ItemCode = choice?.Id,
                 ItemDesc = title,
@@ -268,232 +265,24 @@ namespace BTCPayServer.Controllers
                 Price = price,
                 BuyerEmail = email,
                 OrderId = orderId,
-                NotificationURL = notificationUrl,
-                RedirectURL = redirectUrl  ?? Request.GetDisplayUrl(),
+                NotificationURL =
+                        string.IsNullOrEmpty(notificationUrl) ? settings.NotificationUrl : notificationUrl,
+                NotificationEmail = settings.NotificationEmail,
+                RedirectURL = redirectUrl ?? Request.GetDisplayUrl(),
                 FullNotifications = true,
-                PosData = string.IsNullOrEmpty(posData) ? null : posData
-            }, store, HttpContext.Request.GetAbsoluteRoot());
+                ExtendedNotifications = true,
+                PosData = string.IsNullOrEmpty(posData) ? null : posData,
+                RedirectAutomatically = settings.RedirectAutomatically,
+            }, store, HttpContext.Request.GetAbsoluteRoot(),
+                new List<string>() { AppService.GetAppInternalTag(appId) },
+                cancellationToken);
             return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice", new { invoiceId = invoice.Data.Id });
         }
-        
-        
+
+
         private string GetUserId()
         {
             return _UserManager.GetUserId(User);
         }
     }
-
-    public class AppsHelper
-    {
-        ApplicationDbContextFactory _ContextFactory;
-        CurrencyNameTable _Currencies;
-        private HtmlSanitizer _HtmlSanitizer;
-        public CurrencyNameTable Currencies => _Currencies;
-        public AppsHelper(ApplicationDbContextFactory contextFactory, CurrencyNameTable currencies)
-        {
-            _ContextFactory = contextFactory;
-            _Currencies = currencies;
-            ConfigureSanitizer();
-        }
-        
-        private void ConfigureSanitizer()
-        {
-            
-            _HtmlSanitizer = new HtmlSanitizer();
-
-
-            _HtmlSanitizer.RemovingAtRule += (sender, args) =>
-            {
-                Debug.WriteLine("");
-                
-            };
-            _HtmlSanitizer.RemovingTag += (sender, args) =>
-            {
-                Debug.WriteLine("");
-                if (args.Tag.TagName.Equals("img", StringComparison.InvariantCultureIgnoreCase))
-                {
-                    if (!args.Tag.ClassList.Contains("img-fluid"))
-                    {
-                        args.Tag.ClassList.Add("img-fluid");
-                    }
-
-                    args.Cancel = true;
-                }
-            };
-            
-            _HtmlSanitizer.RemovingAttribute += (sender, args) =>
-            {
-                if (args.Tag.TagName.Equals("img",StringComparison.InvariantCultureIgnoreCase) &&  
-                    args.Attribute.Name.Equals( "src", StringComparison.InvariantCultureIgnoreCase) && 
-                    args.Reason == RemoveReason.NotAllowedUrlValue)
-                {
-                    args.Cancel = true;
-                }
-                Debug.WriteLine("");
-                
-            };
-            _HtmlSanitizer.RemovingStyle += (sender, args) => { args.Cancel = true; };
-            _HtmlSanitizer.AllowedAttributes.Add("class");
-            _HtmlSanitizer.AllowedTags.Add("iframe");
-            _HtmlSanitizer.AllowedTags.Remove("img");
-            _HtmlSanitizer.AllowedAttributes.Add("webkitallowfullscreen");
-            _HtmlSanitizer.AllowedAttributes.Add("allowfullscreen");
-        }
-
-        public string Sanitize(string raw)
-        {
-            return _HtmlSanitizer.Sanitize(raw);
-        }
-        
-        public async Task<StoreData[]> GetOwnedStores(string userId)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                return await ctx.UserStore
-                    .Where(us => us.ApplicationUserId == userId && us.Role == StoreRoles.Owner)
-                    .Select(u => u.StoreData)
-                    .ToArrayAsync();
-            }
-        }
-
-        public async Task<bool> DeleteApp(AppData appData)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                ctx.Apps.Add(appData);
-                ctx.Entry<AppData>(appData).State = EntityState.Deleted;
-                return await ctx.SaveChangesAsync() == 1;
-            }
-        }
-
-        public async Task<ListAppsViewModel.ListAppViewModel[]> GetAllApps(string userId, bool allowNoUser = false)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                return await ctx.UserStore
-                    .Where(us => (allowNoUser && string.IsNullOrEmpty(userId)  ) || us.ApplicationUserId == userId)
-                    .Join(ctx.Apps, us => us.StoreDataId, app => app.StoreDataId,
-                        (us, app) =>
-                            new ListAppsViewModel.ListAppViewModel()
-                            {
-                                IsOwner = us.Role == StoreRoles.Owner,
-                                StoreId = us.StoreDataId,
-                                StoreName = us.StoreData.StoreName,
-                                AppName = app.Name,
-                                AppType = app.AppType,
-                                Id = app.Id
-                            })
-                    .ToArrayAsync();
-            }
-        }
-
-
-        public async Task<AppData> GetApp(string appId, AppType appType, bool includeStore = false)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                var query = ctx.Apps
-                    .Where(us => us.Id == appId &&
-                                 us.AppType == appType.ToString());
-
-                if (includeStore)
-                {
-                    query = query.Include(data => data.StoreData);
-                }
-                return await query.FirstOrDefaultAsync();
-            }
-        }
-
-        public async Task<StoreData> GetStore(AppData app)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                return await ctx.Stores.FirstOrDefaultAsync(s => s.Id == app.StoreDataId);
-            }
-        }
-
-
-        public ViewPointOfSaleViewModel.Item[] Parse(string template, string currency)
-        {
-            if (string.IsNullOrWhiteSpace(template))
-                return Array.Empty<ViewPointOfSaleViewModel.Item>();
-            var input = new StringReader(template);
-            YamlStream stream = new YamlStream();
-            stream.Load(input);
-            var root = (YamlMappingNode)stream.Documents[0].RootNode;
-            return root
-                .Children
-                .Select(kv => new PosHolder { Key = (kv.Key as YamlScalarNode)?.Value, Value = kv.Value as YamlMappingNode })
-                .Where(kv => kv.Value != null)
-                .Select(c => new ViewPointOfSaleViewModel.Item()
-                {
-                    Description = Sanitize(c.GetDetailString("description")),
-                    Id = c.Key,
-                    Image = Sanitize(c.GetDetailString("image")),
-                    Title = Sanitize(c.GetDetailString("title") ?? c.Key),
-                    Price = c.GetDetail("price")
-                             .Select(cc => new ViewPointOfSaleViewModel.Item.ItemPrice()
-                             {
-                                 Value = decimal.Parse(cc.Value.Value, CultureInfo.InvariantCulture),
-                                 Formatted = FormatCurrency(cc.Value.Value, currency)
-                             }).Single(),
-                    Custom = c.GetDetailString("custom") == "true"
-                })
-                .ToArray();
-        }
-
-        private class PosHolder
-        {
-            public string Key { get; set; }
-            public YamlMappingNode Value { get; set; }
-
-            public IEnumerable<PosScalar> GetDetail(string field)
-            {
-                var res = Value.Children
-                                 .Where(kv => kv.Value != null)
-                                 .Select(kv => new PosScalar { Key = (kv.Key as YamlScalarNode)?.Value, Value = kv.Value as YamlScalarNode })
-                                 .Where(cc => cc.Key == field);
-                return res;
-            }
-
-            public string GetDetailString(string field)
-            {
-                
-                return GetDetail(field).FirstOrDefault()?.Value?.Value;
-            }
-        }
-        private class PosScalar
-        {
-            public string Key { get; set; }
-            public YamlScalarNode Value { get; set; }
-        }
-
-        public string FormatCurrency(string price, string currency)
-        {
-            return decimal.Parse(price, CultureInfo.InvariantCulture).ToString("C", _Currencies.GetCurrencyProvider(currency));
-        }
-
-        public CurrencyData GetCurrencyData(string currency, bool useFallback)
-        {
-            return _Currencies.GetCurrencyData(currency, useFallback);
-        }
-        public async Task<AppData> GetAppDataIfOwner(string userId, string appId, AppType? type = null)
-        {
-            if (userId == null || appId == null)
-                return null;
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                var app = await ctx.UserStore
-                                .Where(us => us.ApplicationUserId == userId && us.Role == StoreRoles.Owner)
-                                .SelectMany(us => us.StoreData.Apps.Where(a => a.Id == appId))
-                   .FirstOrDefaultAsync();
-                if (app == null)
-                    return null;
-                if (type != null && type.Value.ToString() != app.AppType)
-                    return null;
-                return app;
-            }
-        }
-        
-    }
 }

BTCPayServer/Controllers/ChangellyController.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Models;
 using BTCPayServer.Payments.Changelly;
@@ -48,7 +49,7 @@ namespace BTCPayServer.Controllers
         [HttpGet]
         [Route("calculate")]
         public async Task<IActionResult> CalculateAmount(string storeId, string fromCurrency, string toCurrency,
-            decimal toCurrencyAmount)
+            decimal toCurrencyAmount, CancellationToken cancellationToken)
         {
             try
             {
@@ -57,7 +58,7 @@ namespace BTCPayServer.Controllers
                 if (fromCurrency.Equals("usd", StringComparison.InvariantCultureIgnoreCase)
                     || fromCurrency.Equals("eur", StringComparison.InvariantCultureIgnoreCase))
                 {
-                    return await HandleCalculateFiatAmount(fromCurrency, toCurrency, toCurrencyAmount);
+                    return await HandleCalculateFiatAmount(fromCurrency, toCurrency, toCurrencyAmount, cancellationToken);
                 }
                 
                 var callCounter = 0;
@@ -102,11 +103,11 @@ namespace BTCPayServer.Controllers
         }
 
         private async Task<IActionResult> HandleCalculateFiatAmount(string fromCurrency, string toCurrency,
-            decimal toCurrencyAmount)
+            decimal toCurrencyAmount, CancellationToken cancellationToken)
         {
             var store = HttpContext.GetStoreData();
             var rules = store.GetStoreBlob().GetRateRules(_btcPayNetworkProvider);
-            var rate = await _RateProviderFactory.FetchRate(new CurrencyPair(toCurrency, fromCurrency), rules);
+            var rate = await _RateProviderFactory.FetchRate(new CurrencyPair(toCurrency, fromCurrency), rules, cancellationToken);
             if (rate.BidAsk == null) return BadRequest();
             var flatRate = rate.BidAsk.Center;
             return Ok(flatRate * toCurrencyAmount);

BTCPayServer/Controllers/HomeController.cs

@@ -1,29 +1,46 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using BTCPayServer.Models;
-using NBitcoin.DataEncoders;
 using NBitcoin.Payment;
 using System.Net.Http;
 using Newtonsoft.Json.Linq;
 using NBitcoin;
 using Newtonsoft.Json;
+using BTCPayServer.Services;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer.Controllers
 {
     public class HomeController : Controller
     {
+        private readonly CssThemeManager _cachedServerSettings;
+
         public IHttpClientFactory HttpClientFactory { get; }
 
-        public HomeController(IHttpClientFactory httpClientFactory)
+        public HomeController(IHttpClientFactory httpClientFactory, CssThemeManager cachedServerSettings)
         {
             HttpClientFactory = httpClientFactory;
+            _cachedServerSettings = cachedServerSettings;
         }
-        public IActionResult Index()
+        
+        public async Task<IActionResult> Index()
         {
+            if (_cachedServerSettings.RootAppType is Services.Apps.AppType.Crowdfund)
+            {
+                var serviceProvider = HttpContext.RequestServices;
+                var controller = (AppsPublicController)serviceProvider.GetService(typeof(AppsPublicController));
+                controller.Url = Url;
+                controller.ControllerContext = ControllerContext;
+                var res = await controller.ViewCrowdfund(_cachedServerSettings.RootAppId, null) as ViewResult;
+                if (res != null)
+                {
+                    res.ViewName = "/Views/AppsPublic/ViewCrowdfund.cshtml";
+                    return res; // return 
+                }
+            }
+
             return View("Home");
         }
 

BTCPayServer/Controllers/InvoiceController.API.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
 using BTCPayServer.Models;
@@ -13,7 +14,6 @@ using NBitpayClient;
 namespace BTCPayServer.Controllers
 {
     [BitpayAPIConstraint]
-    [EnableCors(CorsPolicies.All)]
     [Authorize(Policies.CanCreateInvoice.Key, AuthenticationSchemes = Policies.BitpayAuthentication)]
     public class InvoiceControllerAPI : Controller
     {
@@ -33,9 +33,11 @@ namespace BTCPayServer.Controllers
         [HttpPost]
         [Route("invoices")]
         [MediaTypeConstraint("application/json")]
-        public async Task<DataWrapper<InvoiceResponse>> CreateInvoice([FromBody] Invoice invoice)
+        public async Task<DataWrapper<InvoiceResponse>> CreateInvoice([FromBody] CreateInvoiceRequest invoice, CancellationToken cancellationToken)
         {
-            return await _InvoiceController.CreateInvoiceCore(invoice, HttpContext.GetStoreData(), HttpContext.Request.GetAbsoluteRoot());
+            if (invoice == null)
+                throw new BitpayHttpException(400, "Invalid invoice");
+            return await _InvoiceController.CreateInvoiceCore(invoice, HttpContext.GetStoreData(), HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
         }
 
         [HttpGet]

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -188,7 +188,7 @@ namespace BTCPayServer.Controllers
             //Keep compatibility with Bitpay
             invoiceId = invoiceId ?? id;
             id = invoiceId;
-            ////
+            //
 
             var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
             if (model == null)
@@ -213,6 +213,23 @@ namespace BTCPayServer.Controllers
             return View(nameof(Checkout), model);
         }
 
+        [HttpGet]
+        [Route("invoice-noscript")]
+        public async Task<IActionResult> CheckoutNoScript(string invoiceId, string id = null, string paymentMethodId = null)
+        {
+            //Keep compatibility with Bitpay
+            invoiceId = invoiceId ?? id;
+            id = invoiceId;
+            //
+
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
+            if (model == null)
+                return NotFound();
+
+            return View(model);
+        }
+
+
         private async Task<PaymentModel> GetInvoiceModel(string invoiceId, PaymentMethodId paymentMethodId)
         {
             var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
@@ -273,6 +290,7 @@ namespace BTCPayServer.Controllers
             var model = new PaymentModel()
             {
                 CryptoCode = network.CryptoCode,
+                RootPath = this.Request.PathBase.Value.WithTrailingSlash(),
                 PaymentMethodId = paymentMethodId.ToString(),
                 PaymentMethodName = GetDisplayName(paymentMethodId, network),
                 CryptoImage = GetImage(paymentMethodId, network),
@@ -283,6 +301,7 @@ namespace BTCPayServer.Controllers
                 HtmlTitle = storeBlob.HtmlTitle ?? "BTCPay Invoice",
                 CustomCSSLink = storeBlob.CustomCSS?.AbsoluteUri,
                 CustomLogoLink = storeBlob.CustomLogo?.AbsoluteUri,
+                LightningAmountInSatoshi = storeBlob.LightningAmountInSatoshi,
                 BtcAddress = paymentMethodDetails.GetPaymentDestination(),
                 BtcDue = accounting.Due.ToString(),
                 OrderAmount = (accounting.TotalDue - accounting.NetworkFee).ToString(),
@@ -295,6 +314,7 @@ namespace BTCPayServer.Controllers
                 ItemDesc = invoice.ProductInformation.ItemDesc,
                 Rate = ExchangeRate(paymentMethod),
                 MerchantRefLink = invoice.RedirectURL ?? "/",
+                RedirectAutomatically = invoice.RedirectAutomatically,
                 StoreName = store.StoreName,
                 InvoiceBitcoinUrl = paymentMethodId.PaymentType == PaymentTypes.BTCLike ? cryptoInfo.PaymentUrls.BIP21 :
                                     paymentMethodId.PaymentType == PaymentTypes.LightningLike ? cryptoInfo.PaymentUrls.BOLT11 :
@@ -314,6 +334,7 @@ namespace BTCPayServer.Controllers
                 ChangellyMerchantId = changelly?.ChangellyMerchantId,
                 ChangellyAmountDue = changellyAmountDue,
                 CoinSwitchEnabled = coinswitch != null,
+                CoinSwitchAmountMarkupPercentage = coinswitch?.AmountMarkupPercentage?? 0,
                 CoinSwitchMerchantId = coinswitch?.MerchantId,
                 CoinSwitchMode = coinswitch?.Mode,
                 StoreId = store.Id,
@@ -345,9 +366,8 @@ namespace BTCPayServer.Controllers
 
         private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
         {
-            var res = paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
-                Url.Content(network.CryptoImagePath) : Url.Content(network.LightningImagePath);
-            return "/" + res;
+            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
+                this.Request.GetRelativePathOrAbsolute(network.CryptoImagePath) : this.Request.GetRelativePathOrAbsolute(network.LightningImagePath);
         }
 
         private string OrderAmountFromInvoice(string cryptoCode, ProductInformation productInformation)
@@ -437,7 +457,7 @@ namespace BTCPayServer.Controllers
                 return BadRequest(ModelState);
             }
             await _InvoiceRepository.UpdateInvoice(invoiceId, data).ConfigureAwait(false);
-            return Ok();
+            return Ok("{}");
         }
 
         [HttpGet]
@@ -542,7 +562,7 @@ namespace BTCPayServer.Controllers
         [Route("invoices/create")]
         [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
-        public async Task<IActionResult> CreateInvoice(CreateInvoiceModel model)
+        public async Task<IActionResult> CreateInvoice(CreateInvoiceModel model, CancellationToken cancellationToken)
         {
             var stores = await _StoreRepository.GetStoresByUserId(GetUserId());
             model.Stores = new SelectList(stores, nameof(StoreData.Id), nameof(StoreData.StoreName), model.StoreId);
@@ -578,7 +598,7 @@ namespace BTCPayServer.Controllers
 
             try
             {
-                var result = await CreateInvoiceCore(new Invoice()
+                var result = await CreateInvoiceCore(new CreateInvoiceRequest()
                 {
                     Price = model.Amount.Value,
                     Currency = model.Currency,
@@ -590,7 +610,7 @@ namespace BTCPayServer.Controllers
                     ItemDesc = model.ItemDesc,
                     FullNotifications = true,
                     BuyerEmail = model.BuyerEmail,
-                }, store, HttpContext.Request.GetAbsoluteRoot());
+                }, store, HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
 
                 StatusMessage = $"Invoice {result.Data.Id} just created!";
                 return RedirectToAction(nameof(ListInvoices));
@@ -660,13 +680,13 @@ namespace BTCPayServer.Controllers
             if (newState == "invalid")
             {
                 await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
-                _EventAggregator.Publish(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1008, InvoiceEvent.MarkedInvalid));
+                _EventAggregator.Publish(new InvoiceEvent(invoice, 1008, InvoiceEvent.MarkedInvalid));
                 StatusMessage = "Invoice marked invalid";
             }
             else if(newState == "complete")
             {
                 await _InvoiceRepository.UpdatePaidInvoiceToComplete(invoiceId);
-                _EventAggregator.Publish(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 2008, InvoiceEvent.MarkedCompleted));
+                _EventAggregator.Publish(new InvoiceEvent(invoice, 2008, InvoiceEvent.MarkedCompleted));
                 StatusMessage = "Invoice marked complete";
             }
             return RedirectToAction(nameof(ListInvoices));

BTCPayServer/Controllers/InvoiceController.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Events;
@@ -11,6 +12,7 @@ using BTCPayServer.Models;
 using BTCPayServer.Payments;
 using BTCPayServer.Rating;
 using BTCPayServer.Security;
+using BTCPayServer.Services.Apps;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
 using BTCPayServer.Services.Stores;
@@ -61,7 +63,7 @@ namespace BTCPayServer.Controllers
         }
 
 
-        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl)
+        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(CreateInvoiceRequest invoice, StoreData store, string serverUrl, List<string> additionalTags = null, CancellationToken cancellationToken = default)
         {
             if (!store.HasClaim(Policies.CanCreateInvoice.Key))
                 throw new UnauthorizedAccessException();
@@ -69,12 +71,12 @@ namespace BTCPayServer.Controllers
             logs.Write("Creation of invoice starting");
             var entity = new InvoiceEntity
             {
+                Version = InvoiceEntity.Lastest_Version,
                 InvoiceTime = DateTimeOffset.UtcNow
             };
+
+            var getAppsTaggingStore = _InvoiceRepository.GetAppsTaggingStore(store.Id);
             var storeBlob = store.GetStoreBlob();
-            Uri notificationUri = Uri.IsWellFormedUriString(invoice.NotificationURL, UriKind.Absolute) ? new Uri(invoice.NotificationURL, UriKind.Absolute) : null;
-            if (notificationUri == null || (notificationUri.Scheme != "http" && notificationUri.Scheme != "https")) //TODO: Filer non routable addresses ?
-                notificationUri = null;
             EmailAddressAttribute emailValidator = new EmailAddressAttribute();
             entity.ExpirationTime = entity.InvoiceTime.AddMinutes(storeBlob.InvoiceExpiration);
             entity.MonitoringExpiration = entity.ExpirationTime + TimeSpan.FromMinutes(storeBlob.MonitoringExpiration);
@@ -82,10 +84,18 @@ namespace BTCPayServer.Controllers
             entity.ServerUrl = serverUrl;
             entity.FullNotifications = invoice.FullNotifications || invoice.ExtendedNotifications;
             entity.ExtendedNotifications = invoice.ExtendedNotifications;
-            entity.NotificationURL = notificationUri?.AbsoluteUri;
+            
+            if (invoice.NotificationURL != null &&
+                Uri.TryCreate(invoice.NotificationURL, UriKind.Absolute, out var notificationUri) &&
+                (notificationUri.Scheme == "http" || notificationUri.Scheme == "https"))
+            {
+                entity.NotificationURL = notificationUri.AbsoluteUri;
+            }
             entity.NotificationEmail = invoice.NotificationEmail;
-            entity.BuyerInformation = Map<Invoice, BuyerInformation>(invoice);
+            entity.BuyerInformation = Map<CreateInvoiceRequest, BuyerInformation>(invoice);
             entity.PaymentTolerance = storeBlob.PaymentTolerance;
+            if (additionalTags != null)
+                entity.InternalTags.AddRange(additionalTags);
             //Another way of passing buyer info to support
             FillBuyerInfo(invoice.Buyer, entity.BuyerInformation);
             if (entity?.BuyerInformation?.BuyerEmail != null)
@@ -95,29 +105,47 @@ namespace BTCPayServer.Controllers
                 entity.RefundMail = entity.BuyerInformation.BuyerEmail;
             }
 
+            var taxIncluded = invoice.TaxIncluded.HasValue ? invoice.TaxIncluded.Value : 0m;
+
             var currencyInfo = _CurrencyNameTable.GetNumberFormatInfo(invoice.Currency, false);
             if (currencyInfo != null)
             {
-                invoice.Price = Math.Round(invoice.Price, currencyInfo.CurrencyDecimalDigits);
-                invoice.TaxIncluded = Math.Round(invoice.TaxIncluded, currencyInfo.CurrencyDecimalDigits);
+                int divisibility = currencyInfo.CurrencyDecimalDigits;
+                invoice.Price = invoice.Price.RoundToSignificant(ref divisibility);
+                divisibility = currencyInfo.CurrencyDecimalDigits;
+                invoice.TaxIncluded = taxIncluded.RoundToSignificant(ref divisibility);
             }
             invoice.Price = Math.Max(0.0m, invoice.Price);
-            invoice.TaxIncluded = Math.Max(0.0m, invoice.TaxIncluded);
-            invoice.TaxIncluded = Math.Min(invoice.TaxIncluded, invoice.Price);
+            invoice.TaxIncluded = Math.Max(0.0m, taxIncluded);
+            invoice.TaxIncluded = Math.Min(taxIncluded, invoice.Price);
 
-            entity.ProductInformation = Map<Invoice, ProductInformation>(invoice);
+            entity.ProductInformation = Map<CreateInvoiceRequest, ProductInformation>(invoice);
 
 
             entity.RedirectURL = invoice.RedirectURL ?? store.StoreWebsite;
             if (!Uri.IsWellFormedUriString(entity.RedirectURL, UriKind.Absolute))
                 entity.RedirectURL = null;
 
+            entity.RedirectAutomatically =
+                invoice.RedirectAutomatically.GetValueOrDefault(storeBlob.RedirectAutomatically);
+
             entity.Status = InvoiceStatus.New;
             entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
 
             HashSet<CurrencyPair> currencyPairsToFetch = new HashSet<CurrencyPair>();
             var rules = storeBlob.GetRateRules(_NetworkProvider);
             var excludeFilter = storeBlob.GetExcludedPaymentMethods(); // Here we can compose filters from other origin with PaymentFilter.Any()
+
+            if (invoice.SupportedTransactionCurrencies != null && invoice.SupportedTransactionCurrencies.Count != 0)
+            {
+                var supportedTransactionCurrencies = invoice.SupportedTransactionCurrencies
+                                                            .Where(c => c.Value.Enabled)
+                                                            .Select(c => PaymentMethodId.TryParse(c.Key, out var p) ? p : null)
+                                                            .ToHashSet();
+                excludeFilter = PaymentFilter.Or(excludeFilter,
+                                                 PaymentFilter.Where(p => !supportedTransactionCurrencies.Contains(p)));
+            }
+
             foreach (var network in store.GetSupportedPaymentMethods(_NetworkProvider)
                                                 .Where(s => !excludeFilter.Match(s.PaymentId))
                                                 .Select(c => _NetworkProvider.GetNetwork(c.PaymentId.CryptoCode))
@@ -131,7 +159,7 @@ namespace BTCPayServer.Controllers
             }
 
             var rateRules = storeBlob.GetRateRules(_NetworkProvider);
-            var fetchingByCurrencyPair = _RateProvider.FetchRates(currencyPairsToFetch, rateRules);
+            var fetchingByCurrencyPair = _RateProvider.FetchRates(currencyPairsToFetch, rateRules, cancellationToken);
 
             var fetchingAll = WhenAllFetched(logs, fetchingByCurrencyPair);
             var supportedPaymentMethods = store.GetSupportedPaymentMethods(_NetworkProvider)
@@ -170,9 +198,29 @@ namespace BTCPayServer.Controllers
             entity.SetSupportedPaymentMethods(supported);
             entity.SetPaymentMethods(paymentMethods);
             entity.PosData = invoice.PosData;
-            entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, logs, _NetworkProvider);
-            await fetchingAll;
-            _EventAggregator.Publish(new Events.InvoiceEvent(entity.EntityToDTO(_NetworkProvider), 1001, InvoiceEvent.Created));
+
+            foreach (var app in await getAppsTaggingStore)
+            {
+                entity.InternalTags.Add(AppService.GetAppInternalTag(app.Id));
+            }
+
+            using (logs.Measure("Saving invoice"))
+            {
+                entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
+            }
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await fetchingAll;
+                }
+                catch (AggregateException ex)
+                {
+                    ex.Handle(e => { logs.Write($"Error while fetching rates {ex}"); return true; });
+                }
+                await _InvoiceRepository.AddInvoiceLogs(entity.Id, logs);
+            });
+            _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, InvoiceEvent.Created));
             var resp = entity.EntityToDTO(_NetworkProvider);
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }
@@ -200,6 +248,7 @@ namespace BTCPayServer.Controllers
         {
             try
             {
+                var logPrefix = $"{supportedPaymentMethod.PaymentId.ToString(true)}:";
                 var storeBlob = store.GetStoreBlob();
                 var preparePayment = handler.PreparePayment(supportedPaymentMethod, store, network);
                 var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
@@ -212,8 +261,13 @@ namespace BTCPayServer.Controllers
                 paymentMethod.Network = network;
                 paymentMethod.SetId(supportedPaymentMethod.PaymentId);
                 paymentMethod.Rate = rate.BidAsk.Bid;
-                var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network, preparePayment);
-                paymentMethod.SetPaymentMethodDetails(paymentDetails);
+                paymentMethod.PreferOnion = this.Request.IsOnion();
+
+                using (logs.Measure($"{logPrefix} Payment method details creation"))
+                {
+                    var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network, preparePayment);
+                    paymentMethod.SetPaymentMethodDetails(paymentDetails);
+                }
 
                 Func<Money, Money, bool> compare = null;
                 CurrencyValue limitValue = null;
@@ -241,7 +295,7 @@ namespace BTCPayServer.Controllers
                         var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.BidAsk.Bid);
                         if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
                         {
-                            logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: {errorMessage}");
+                            logs.Write($"{logPrefix} {errorMessage}");
                             return null;
                         }
                     }

BTCPayServer/Controllers/Macaroons.cs

@@ -25,7 +25,7 @@ namespace BTCPayServer.Controllers
                 throw new ArgumentNullException(nameof(directoryPath));
             Macaroons macaroons = new Macaroons();
             if (!Directory.Exists(directoryPath))
-                return macaroons;
+                throw new DirectoryNotFoundException("Macaroons directory not found");
             foreach(var file in Directory.GetFiles(directoryPath, "*.macaroon"))
             {
                 try
@@ -49,6 +49,17 @@ namespace BTCPayServer.Controllers
             }
             return macaroons;
         }
+
+        public Macaroons Clone()
+        {
+            return new Macaroons()
+            {
+                AdminMacaroon = AdminMacaroon,
+                InvoiceMacaroon = InvoiceMacaroon,
+                ReadonlyMacaroon = ReadonlyMacaroon
+            };
+        }
+
         public Macaroon ReadonlyMacaroon { get; set; }
 
         public Macaroon InvoiceMacaroon { get; set; }

BTCPayServer/Controllers/ManageController.cs

@@ -113,6 +113,7 @@ namespace BTCPayServer.Controllers
                 {
                     throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'.");
                 }
+                await _userManager.SetUserNameAsync(user, model.Username);
             }
 
             var phoneNumber = user.PhoneNumber;

BTCPayServer/Controllers/PaymentRequestController.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Filters;
+using BTCPayServer.Models;
+using BTCPayServer.Models.PaymentRequestViewModels;
+using BTCPayServer.PaymentRequest;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Rating;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.PaymentRequests;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using Ganss.XSS;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using NBitpayClient;
+
+namespace BTCPayServer.Controllers
+{
+    [Route("payment-requests")]
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    public class PaymentRequestController : Controller
+    {
+        private readonly InvoiceController _InvoiceController;
+        private readonly UserManager<ApplicationUser> _UserManager;
+        private readonly StoreRepository _StoreRepository;
+        private readonly PaymentRequestRepository _PaymentRequestRepository;
+        private readonly PaymentRequestService _PaymentRequestService;
+        private readonly EventAggregator _EventAggregator;
+        private readonly CurrencyNameTable _Currencies;
+        private readonly HtmlSanitizer _htmlSanitizer;
+
+        public PaymentRequestController(
+            InvoiceController invoiceController,
+            UserManager<ApplicationUser> userManager,
+            StoreRepository storeRepository,
+            PaymentRequestRepository paymentRequestRepository,
+            PaymentRequestService paymentRequestService,
+            EventAggregator eventAggregator,
+            CurrencyNameTable currencies,
+            HtmlSanitizer htmlSanitizer)
+        {
+            _InvoiceController = invoiceController;
+            _UserManager = userManager;
+            _StoreRepository = storeRepository;
+            _PaymentRequestRepository = paymentRequestRepository;
+            _PaymentRequestService = paymentRequestService;
+            _EventAggregator = eventAggregator;
+            _Currencies = currencies;
+            _htmlSanitizer = htmlSanitizer;
+        }
+
+        [HttpGet]
+        [Route("")]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> GetPaymentRequests(int skip = 0, int count = 50, string statusMessage = null)
+        {
+            var result = await _PaymentRequestRepository.FindPaymentRequests(new PaymentRequestQuery()
+            {
+                UserId = GetUserId(), Skip = skip, Count = count
+            });
+            return View(new ListPaymentRequestsViewModel()
+            {
+                Skip = skip,
+                StatusMessage = statusMessage,
+                Count = count,
+                Total = result.Total,
+                Items = result.Items.Select(data => new ViewPaymentRequestViewModel(data)).ToList()
+            });
+        }
+
+        [HttpGet]
+        [Route("edit/{id?}")]
+        public async Task<IActionResult> EditPaymentRequest(string id, string statusMessage = null)
+        {
+            SelectList stores = null;
+            var data = await _PaymentRequestRepository.FindPaymentRequest(id, GetUserId());
+            if (data == null && !string.IsNullOrEmpty(id))
+            {
+                return NotFound();
+            }
+
+            stores = new SelectList(await _StoreRepository.GetStoresByUserId(GetUserId()), nameof(StoreData.Id),
+                nameof(StoreData.StoreName), data?.StoreDataId);
+            if (!stores.Any())
+            {
+                return RedirectToAction("GetPaymentRequests",
+                    new
+                    {
+                        StatusMessage = new StatusMessageModel()
+                        {
+                            Html =
+                                $"Error: You need to create at least one store. <a href='{Url.Action("CreateStore", "UserStores")}'>Create store</a>",
+                            Severity = StatusMessageModel.StatusSeverity.Error
+                        }
+                    });
+            }
+
+            return View(new UpdatePaymentRequestViewModel(data)
+            {
+                Stores = stores,
+                StatusMessage = statusMessage
+            });
+        }
+
+        [HttpPost]
+        [Route("edit/{id?}")]
+        public async Task<IActionResult> EditPaymentRequest(string id, UpdatePaymentRequestViewModel viewModel)
+        {
+            if (string.IsNullOrEmpty(viewModel.Currency) ||
+                _Currencies.GetCurrencyData(viewModel.Currency, false) == null)
+                ModelState.AddModelError(nameof(viewModel.Currency), "Invalid currency");
+
+            var data = await _PaymentRequestRepository.FindPaymentRequest(id, GetUserId());
+            if (data == null && !string.IsNullOrEmpty(id))
+            {
+                return NotFound();
+            }
+
+            if (!ModelState.IsValid)
+            {
+                viewModel.Stores = new SelectList(await _StoreRepository.GetStoresByUserId(GetUserId()),
+                    nameof(StoreData.Id),
+                    nameof(StoreData.StoreName), data?.StoreDataId);
+
+                return View(viewModel);
+            }
+
+            if (data == null)
+            {
+                data = new PaymentRequestData();
+            }
+
+            data.StoreDataId = viewModel.StoreId;
+            var blob = data.GetBlob();
+
+            blob.Title = viewModel.Title;
+            blob.Email = viewModel.Email;
+            blob.Description = _htmlSanitizer.Sanitize(viewModel.Description);
+            blob.Amount = viewModel.Amount;
+            blob.ExpiryDate = viewModel.ExpiryDate;
+            blob.Currency = viewModel.Currency;
+            blob.EmbeddedCSS = viewModel.EmbeddedCSS;
+            blob.CustomCSSLink = viewModel.CustomCSSLink;
+            blob.AllowCustomPaymentAmounts = viewModel.AllowCustomPaymentAmounts;
+
+            data.SetBlob(blob);
+            data = await _PaymentRequestRepository.CreateOrUpdatePaymentRequest(data);
+            _EventAggregator.Publish(new PaymentRequestUpdated()
+            {
+                Data = data,
+                PaymentRequestId = data.Id
+            });
+
+            return RedirectToAction("EditPaymentRequest", new {id = data.Id, StatusMessage = "Saved"});
+        }
+
+        [HttpGet]
+        [Route("{id}/remove")]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> RemovePaymentRequestPrompt(string id)
+        {
+            var data = await _PaymentRequestRepository.FindPaymentRequest(id, GetUserId());
+            if (data == null)
+            {
+                return NotFound();
+            }
+
+            var blob = data.GetBlob();
+            return View("Confirm", new ConfirmModel()
+            {
+                Title = $"Remove Payment Request",
+                Description = $"Are you sure you want to remove access to the payment request '{blob.Title}' ?",
+                Action = "Delete"
+            });
+        }
+
+        [HttpPost]
+        [Route("{id}/remove")]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> RemovePaymentRequest(string id)
+        {
+            var result = await _PaymentRequestRepository.RemovePaymentRequest(id, GetUserId());
+            if (result)
+            {
+                return RedirectToAction("GetPaymentRequests",
+                    new {StatusMessage = "Payment request successfully removed"});
+            }
+            else
+            {
+                return RedirectToAction("GetPaymentRequests",
+                    new
+                    {
+                        StatusMessage =
+                            "Error: Payment request could not be removed. Any request that has generated invoices cannot be removed."
+                    });
+            }
+        }
+
+        [HttpGet]
+        [Route("{id}")]
+        [AllowAnonymous]
+        public async Task<IActionResult> ViewPaymentRequest(string id)
+        {
+            var result = await _PaymentRequestService.GetPaymentRequest(id, GetUserId());
+            if (result == null)
+            {
+                return NotFound();
+            }
+            result.HubPath = PaymentRequestHub.GetHubPath(this.Request);
+            return View(result);
+        }
+
+        [HttpGet]
+        [Route("{id}/pay")]
+        [AllowAnonymous]
+        public async Task<IActionResult> PayPaymentRequest(string id, bool redirectToInvoice = true,
+            decimal? amount = null, CancellationToken cancellationToken = default)
+        {
+            var result = await _PaymentRequestService.GetPaymentRequest(id, GetUserId());
+            if (result == null)
+            {
+                return NotFound();
+            }
+            result.HubPath = PaymentRequestHub.GetHubPath(this.Request);
+            if (result.AmountDue <= 0)
+            {
+                if (redirectToInvoice)
+                {
+                    return RedirectToAction("ViewPaymentRequest", new {Id = id});
+                }
+
+                return BadRequest("Payment Request has already been settled.");
+            }
+
+            if (result.ExpiryDate.HasValue && DateTime.Now >= result.ExpiryDate)
+            {
+                if (redirectToInvoice)
+                {
+                    return RedirectToAction("ViewPaymentRequest", new {Id = id});
+                }
+
+                return BadRequest("Payment Request has expired");
+            }
+
+            var statusesAllowedToDisplay = new List<InvoiceStatus>()
+            {
+                InvoiceStatus.New
+            };
+            var validInvoice = result.Invoices.FirstOrDefault(invoice =>
+                Enum.TryParse<InvoiceStatus>(invoice.Status, true, out var status) &&
+                statusesAllowedToDisplay.Contains(status));
+
+            if (validInvoice != null)
+            {
+                if (redirectToInvoice)
+                {
+                    return RedirectToAction("Checkout", "Invoice", new {Id = validInvoice.Id});
+                }
+
+                return Ok(validInvoice.Id);
+            }
+
+            if (result.AllowCustomPaymentAmounts && amount != null)
+                amount = Math.Min(result.AmountDue, amount.Value);
+            else
+                amount = result.AmountDue;
+
+
+            var pr = await _PaymentRequestRepository.FindPaymentRequest(id, null);
+            var blob = pr.GetBlob();
+            var store = pr.StoreData;
+            store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
+            try
+            {
+                var redirectUrl = Request.GetDisplayUrl().TrimEnd("/pay", StringComparison.InvariantCulture)
+                    .Replace("hub?id=", string.Empty, StringComparison.InvariantCultureIgnoreCase);
+                var newInvoiceId = (await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
+                        {
+                            OrderId = $"{PaymentRequestRepository.GetOrderIdForPaymentRequest(id)}",
+                            Currency = blob.Currency,
+                            Price = amount.Value,
+                            FullNotifications = true,
+                            BuyerEmail = result.Email,
+                            RedirectURL = redirectUrl,
+                        }, store, HttpContext.Request.GetAbsoluteRoot(),
+                        new List<string>() {PaymentRequestRepository.GetInternalTag(id)},
+                        cancellationToken: cancellationToken))
+                    .Data.Id;
+
+                if (redirectToInvoice)
+                {
+                    return RedirectToAction("Checkout", "Invoice", new {Id = newInvoiceId});
+                }
+
+                return Ok(newInvoiceId);
+            }
+            catch (BitpayHttpException e)
+            {
+                return BadRequest(e.Message);
+            }
+        }
+
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+
+        [HttpGet]
+        [Route("{id}/clone")]
+        public async Task<IActionResult> ClonePaymentRequest(string id)
+        {
+            var result = await EditPaymentRequest(id);
+            if (result is ViewResult viewResult)
+            {
+                var model = (UpdatePaymentRequestViewModel)viewResult.Model;
+                model.Id = null;
+                model.Title = $"Clone of {model.Title}";
+                
+                return View("EditPaymentRequest", model);
+                
+            }
+
+            return NotFound();
+        }
+    }
+}

BTCPayServer/Controllers/PublicController.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
+using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Services.Stores;
 using Microsoft.AspNetCore.Cors;
@@ -27,7 +29,7 @@ namespace BTCPayServer.Controllers
         [MediaTypeAcceptConstraintAttribute("text/html")]
         [IgnoreAntiforgeryToken]
         [EnableCors(CorsPolicies.All)]
-        public async Task<IActionResult> PayButtonHandle([FromForm]PayButtonViewModel model)
+        public async Task<IActionResult> PayButtonHandle([FromForm]PayButtonViewModel model, CancellationToken cancellationToken)
         {
             var store = await _StoreRepository.FindStore(model.StoreId);
             if (store == null)
@@ -45,7 +47,7 @@ namespace BTCPayServer.Controllers
             if (!ModelState.IsValid)
                 return View();
 
-            var invoice = await _InvoiceController.CreateInvoiceCore(new NBitpayClient.Invoice()
+            var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
             {
                 Price = model.Price,
                 Currency = model.Currency,
@@ -55,7 +57,7 @@ namespace BTCPayServer.Controllers
                 NotificationURL = model.ServerIpn,
                 RedirectURL = model.BrowserRedirect,
                 FullNotifications = true
-            }, store, HttpContext.Request.GetAbsoluteRoot());
+            }, store, HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
             return Redirect(invoice.Data.Url);
         }
     }

BTCPayServer/Controllers/PublicLightningNodeInfoController.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
+using BTCPayServer.Filters;
 using BTCPayServer.Lightning;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Payments;
@@ -30,6 +31,7 @@ namespace BTCPayServer.Controllers
         }
         
         [HttpGet]
+        [XFrameOptions(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
         public async Task<IActionResult> ShowLightningNodeInfo(string storeId, string cryptoCode)
         {
             var store = await _StoreRepository.FindStore(storeId);
@@ -41,7 +43,7 @@ namespace BTCPayServer.Controllers
                 var paymentMethodDetails = GetExistingLightningSupportedPaymentMethod(cryptoCode, store);
                 var network = _BtcPayNetworkProvider.GetNetwork(cryptoCode);
                 var nodeInfo =
-                    await _LightningLikePaymentHandler.GetNodeInfo(paymentMethodDetails,
+                    await _LightningLikePaymentHandler.GetNodeInfo(this.Request.IsOnion(), paymentMethodDetails,
                         network);
 
                 return View(new ShowLightningNodeInfoViewModel()

BTCPayServer/Controllers/RateController.cs

@@ -13,6 +13,7 @@ using Newtonsoft.Json;
 using Microsoft.AspNetCore.Authorization;
 using BTCPayServer.Authentication;
 using Microsoft.AspNetCore.Cors;
+using System.Threading;
 
 namespace BTCPayServer.Controllers
 {
@@ -45,7 +46,7 @@ namespace BTCPayServer.Controllers
         [Route("rates/{baseCurrency}")]
         [HttpGet]
         [BitpayAPIConstraint]
-        public async Task<IActionResult> GetBaseCurrencyRates(string baseCurrency, string storeId)
+        public async Task<IActionResult> GetBaseCurrencyRates(string baseCurrency, string storeId, CancellationToken cancellationToken)
         {
             storeId = await GetStoreId(storeId);
             var store = this.HttpContext.GetStoreData();
@@ -64,7 +65,7 @@ namespace BTCPayServer.Controllers
 
             var currencypairs = BuildCurrencyPairs(currencyCodes, baseCurrency);
             
-            var result = await GetRates2(currencypairs, store.Id);
+            var result = await GetRates2(currencypairs, store.Id, cancellationToken);
             var rates = (result as JsonResult)?.Value as Rate[];
             if (rates == null)
                 return result;
@@ -75,10 +76,10 @@ namespace BTCPayServer.Controllers
         [Route("rates/{baseCurrency}/{currency}")]
         [HttpGet]
         [BitpayAPIConstraint]
-        public async Task<IActionResult> GetCurrencyPairRate(string baseCurrency, string currency, string storeId)
+        public async Task<IActionResult> GetCurrencyPairRate(string baseCurrency, string currency, string storeId, CancellationToken cancellationToken)
         {
             storeId = await GetStoreId(storeId);
-            var result = await GetRates2($"{baseCurrency}_{currency}", storeId);
+            var result = await GetRates2($"{baseCurrency}_{currency}", storeId, cancellationToken);
             var rates = (result as JsonResult)?.Value as Rate[];
             if (rates == null)
                 return result;
@@ -88,10 +89,9 @@ namespace BTCPayServer.Controllers
         [Route("rates")]
         [HttpGet]
         [BitpayAPIConstraint]
-        public async Task<IActionResult> GetRates(string currencyPairs, string storeId)
+        public async Task<IActionResult> GetRates(string currencyPairs, string storeId, CancellationToken cancellationToken)
         {
-            storeId = await GetStoreId(storeId);
-            var result = await GetRates2(currencyPairs, storeId);
+            var result = await GetRates2(currencyPairs, storeId, cancellationToken);
             var rates = (result as JsonResult)?.Value as Rate[];
             if (rates == null)
                 return result;
@@ -118,7 +118,7 @@ namespace BTCPayServer.Controllers
 
         [Route("api/rates")]
         [HttpGet]
-        public async Task<IActionResult> GetRates2(string currencyPairs, string storeId)
+        public async Task<IActionResult> GetRates2(string currencyPairs, string storeId, CancellationToken cancellationToken)
         {
             storeId = await GetStoreId(storeId);
             if (storeId == null)
@@ -139,15 +139,10 @@ namespace BTCPayServer.Controllers
 
             if (currencyPairs == null)
             {
-                var supportedMethods = store.GetSupportedPaymentMethods(_NetworkProvider);
-                var currencyCodes = supportedMethods.Select(method => method.PaymentId.CryptoCode).Distinct();
-                var defaultPaymentId = store.GetDefaultPaymentId(_NetworkProvider);
-
-                currencyPairs = BuildCurrencyPairs(currencyCodes, defaultPaymentId.CryptoCode);
-
+                currencyPairs = store.GetStoreBlob().GetDefaultCurrencyPairString();
                 if (string.IsNullOrEmpty(currencyPairs))
                 {
-                    var result = Json(new BitpayErrorsModel() { Error = "You need to specify currencyPairs (eg. BTC_USD,LTC_CAD)" });
+                    var result = Json(new BitpayErrorsModel() { Error = "You need to setup the default currency pairs in 'Store Settings / Rates' or specify 'currencyPairs' query parameter (eg. BTC_USD,LTC_CAD)." });
                     result.StatusCode = 400;
                     return result;
                 }
@@ -168,7 +163,7 @@ namespace BTCPayServer.Controllers
                 pairs.Add(pair);
             }
 
-            var fetching = _RateProviderFactory.FetchRates(pairs, rules);
+            var fetching = _RateProviderFactory.FetchRates(pairs, rules, cancellationToken);
             await Task.WhenAll(fetching.Select(f => f.Value).ToArray());
             return Json(pairs
                             .Select(r => (Pair: r, Value: fetching[r].GetAwaiter().GetResult().BidAsk?.Bid))

BTCPayServer/Controllers/ServerController.cs

@@ -26,7 +26,10 @@ using System.Threading.Tasks;
 using Renci.SshNet;
 using BTCPayServer.Logging;
 using BTCPayServer.Lightning;
-using BTCPayServer.Configuration.External;
+using System.Runtime.CompilerServices;
+using BTCPayServer.Services.Apps;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using BTCPayServer.Data;
 
 namespace BTCPayServer.Controllers
 {
@@ -39,16 +42,20 @@ namespace BTCPayServer.Controllers
         private RateFetcher _RateProviderFactory;
         private StoreRepository _StoreRepository;
         LightningConfigurationProvider _LnConfigProvider;
+        private readonly TorServices _torServices;
         BTCPayServerOptions _Options;
+        ApplicationDbContextFactory _ContextFactory;
 
         public ServerController(UserManager<ApplicationUser> userManager,
-            Configuration.BTCPayServerOptions options,
+            BTCPayServerOptions options,
             RateFetcher rateProviderFactory,
             SettingsRepository settingsRepository,
             NBXplorerDashboard dashBoard,
             IHttpClientFactory httpClientFactory,
             LightningConfigurationProvider lnConfigProvider,
-            Services.Stores.StoreRepository storeRepository)
+            TorServices torServices,
+            StoreRepository storeRepository,
+            ApplicationDbContextFactory contextFactory)
         {
             _Options = options;
             _UserManager = userManager;
@@ -58,6 +65,8 @@ namespace BTCPayServer.Controllers
             _RateProviderFactory = rateProviderFactory;
             _StoreRepository = storeRepository;
             _LnConfigProvider = lnConfigProvider;
+            _torServices = torServices;
+            _ContextFactory = contextFactory;
         }
 
         [Route("server/rates")]
@@ -170,7 +179,7 @@ namespace BTCPayServer.Controllers
                 vm.DNSDomain = null;
             return View(vm);
         }
-        
+
         [Route("server/maintenance")]
         [HttpPost]
         public async Task<IActionResult> Maintenance(MaintenanceViewModel vm, string command)
@@ -246,6 +255,13 @@ namespace BTCPayServer.Controllers
                     return error;
                 StatusMessage = $"The server might restart soon if an update is available...";
             }
+            else if (command == "clean")
+            {
+                var error = RunSSH(vm, $"btcpay-clean.sh");
+                if (error != null)
+                    return error;
+                StatusMessage = $"The old docker images will be cleaned soon...";
+            }
             else
             {
                 return NotFound();
@@ -352,22 +368,27 @@ namespace BTCPayServer.Controllers
             var user = await _UserManager.FindByIdAsync(userId);
             if (user == null)
                 return NotFound();
-            var roles = await _UserManager.GetRolesAsync(user);
-            var isAdmin = IsAdmin(roles);
-            bool updated = false;
 
-            if (isAdmin != viewModel.IsAdmin)
+            viewModel.StatusMessage = "";
+
+            var admins = await _UserManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+            if (!viewModel.IsAdmin && admins.Count == 1)
+            {
+                viewModel.StatusMessage = "This is the only Admin, so their role can't be removed until another Admin is added.";
+                return View(viewModel); // return
+            }
+
+            var roles = await _UserManager.GetRolesAsync(user);
+            if (viewModel.IsAdmin != IsAdmin(roles))
             {
                 if (viewModel.IsAdmin)
                     await _UserManager.AddToRoleAsync(user, Roles.ServerAdmin);
                 else
                     await _UserManager.RemoveFromRoleAsync(user, Roles.ServerAdmin);
-                updated = true;
-            }
-            if (updated)
-            {
+
                 viewModel.StatusMessage = "User successfully updated";
             }
+
             return View(viewModel);
         }
 
@@ -378,12 +399,28 @@ namespace BTCPayServer.Controllers
             var user = userId == null ? null : await _UserManager.FindByIdAsync(userId);
             if (user == null)
                 return NotFound();
-            return View("Confirm", new ConfirmModel()
+
+            var roles = await _UserManager.GetRolesAsync(user);
+            if (IsAdmin(roles))
             {
-                Title = "Delete user " + user.Email,
-                Description = "This user will be permanently deleted",
-                Action = "Delete"
-            });
+                var admins = await _UserManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+                if (admins.Count == 1)
+                {
+                    // return
+                    return View("Confirm", new ConfirmModel("Unable to Delete Last Admin",
+                        "This is the last Admin, so it can't be removed"));
+                }
+
+                return View("Confirm", new ConfirmModel("Delete Admin " + user.Email,
+                    "Are you sure you want to delete this Admin and delete all accounts, users and data associated with the server account?",
+                    "Delete"));
+            }
+            else
+            {
+                return View("Confirm", new ConfirmModel("Delete user " + user.Email,
+                                    "This user will be permanently deleted",
+                                    "Delete"));
+            }
         }
 
         [Route("server/users/{userId}/delete")]
@@ -406,214 +443,197 @@ namespace BTCPayServer.Controllers
         }
         public IHttpClientFactory HttpClientFactory { get; }
 
-        [Route("server/emails")]
-        public async Task<IActionResult> Emails()
-        {
-            var data = (await _SettingsRepository.GetSettingAsync<EmailSettings>()) ?? new EmailSettings();
-            return View(new EmailsViewModel() { Settings = data });
-        }
-
         [Route("server/policies")]
         public async Task<IActionResult> Policies()
         {
             var data = (await _SettingsRepository.GetSettingAsync<PoliciesSettings>()) ?? new PoliciesSettings();
+
+            // load display app dropdown
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                var userId = _UserManager.GetUserId(base.User);
+                var selectList = ctx.Users.Where(user => user.Id == userId)
+                                .SelectMany(s => s.UserStores)
+                                .Select(s => s.StoreData)
+                                .SelectMany(s => s.Apps)
+                                .Select(a => new SelectListItem($"{a.AppType} - {a.Name}", a.Id)).ToList();
+                selectList.Insert(0, new SelectListItem("(None)", null));
+                ViewBag.AppsList = new SelectList(selectList, "Value", "Text", data.RootAppId);
+            }
+
             return View(data);
         }
         [Route("server/policies")]
         [HttpPost]
         public async Task<IActionResult> Policies(PoliciesSettings settings)
         {
+            if (!String.IsNullOrEmpty(settings.RootAppId))
+            {
+                using (var ctx = _ContextFactory.CreateContext())
+                {
+                    var app = ctx.Apps.SingleOrDefault(a => a.Id == settings.RootAppId);
+                    if (app != null)
+                        settings.RootAppType = Enum.Parse<AppType>(app.AppType);
+                    else
+                        settings.RootAppType = null;
+                }
+            }
+            else
+            {
+                // not preserved on client side, but clearing it just in case
+                settings.RootAppType = null;
+            }
+
             await _SettingsRepository.UpdateSetting(settings);
             TempData["StatusMessage"] = "Policies updated successfully";
-            return View(settings);
+            return RedirectToAction(nameof(Policies));
         }
 
         [Route("server/services")]
         public IActionResult Services()
         {
             var result = new ServicesViewModel();
-            foreach (var cryptoCode in _Options.ExternalServicesByCryptoCode.Keys)
+            result.ExternalServices = _Options.ExternalServices;
+            foreach (var externalService in _Options.OtherExternalServices)
             {
-                int i = 0;
-                foreach (var grpcService in _Options.ExternalServicesByCryptoCode.GetServices<ExternalLnd>(cryptoCode))
-                {
-                    result.LNDServices.Add(new ServicesViewModel.LNDServiceViewModel()
-                    {
-                        Crypto = cryptoCode,
-                        Type = grpcService.Type,
-                        Action = nameof(LndServices),
-                        Index = i++,
-                    });
-                }
-                i = 0;
-                foreach (var sparkService in _Options.ExternalServicesByCryptoCode.GetServices<ExternalSpark>(cryptoCode))
-                {
-                    result.LNDServices.Add(new ServicesViewModel.LNDServiceViewModel()
-                    {
-                        Crypto = cryptoCode,
-                        Type = "Spark server",
-                        Action = nameof(SparkServices),
-                        Index = i++,
-                    });
-                }
-                foreach (var chargeService in _Options.ExternalServicesByCryptoCode.GetServices<ExternalCharge>(cryptoCode))
-                {
-                    result.LNDServices.Add(new ServicesViewModel.LNDServiceViewModel()
-                    {
-                        Crypto = cryptoCode,
-                        Type = "Lightning charge server",
-                        Action = nameof(LightningChargeServices),
-                        Index = i++,
-                    });
-                }
-            }
-            foreach(var externalService in _Options.ExternalServices)
-            {
-                result.ExternalServices.Add(new ServicesViewModel.ExternalService()
+                result.OtherExternalServices.Add(new ServicesViewModel.OtherExternalService()
                 {
                     Name = externalService.Key,
-                    Link = this.Request.GetRelativePathOrAbsolute(externalService.Value)
+                    Link = this.Request.GetAbsoluteUriNoPathBase(externalService.Value).AbsoluteUri
                 });
             }
-            if(_Options.SSHSettings != null)
+            if (_Options.SSHSettings != null)
             {
-                result.ExternalServices.Add(new ServicesViewModel.ExternalService()
+                result.OtherExternalServices.Add(new ServicesViewModel.OtherExternalService()
                 {
                     Name = "SSH",
                     Link = this.Url.Action(nameof(SSHService))
                 });
             }
+            foreach (var torService in _torServices.Services)
+            {
+                if (torService.VirtualPort == 80)
+                {
+                    result.TorHttpServices.Add(new ServicesViewModel.OtherExternalService()
+                    {
+                        Name = torService.Name,
+                        Link = $"http://{torService.OnionHost}"
+                    });
+                }
+                else
+                {
+                    result.TorOtherServices.Add(new ServicesViewModel.OtherExternalService()
+                    {
+                        Name = torService.Name,
+                        Link = $"{torService.OnionHost}:{torService.VirtualPort}"
+                    });
+                }
+            }
             return View(result);
         }
 
-        [Route("server/services/lightning-charge/{cryptoCode}/{index}")]
-        public async Task<IActionResult> LightningChargeServices(string cryptoCode, int index, bool showQR = false)
+        [Route("server/services/{serviceName}/{cryptoCode}")]
+        public async Task<IActionResult> Service(string serviceName, string cryptoCode, bool showQR = false, uint? nonce = null)
         {
             if (!_dashBoard.IsFullySynched(cryptoCode, out var unusud))
             {
                 StatusMessage = $"Error: {cryptoCode} is not fully synched";
                 return RedirectToAction(nameof(Services));
             }
-            var lightningCharge = _Options.ExternalServicesByCryptoCode.GetServices<ExternalCharge>(cryptoCode).Select(c => c.ConnectionString).FirstOrDefault();
-            if (lightningCharge == null)
-            {
+            var service = _Options.ExternalServices.GetService(serviceName, cryptoCode);
+            if (service == null)
                 return NotFound();
-            }
 
-            ChargeServiceViewModel vm = new ChargeServiceViewModel();
-            vm.Uri = lightningCharge.ToUri(false).AbsoluteUri;
-            vm.APIToken = lightningCharge.Password;
             try
             {
-                if (string.IsNullOrEmpty(vm.APIToken) && lightningCharge.CookieFilePath != null)
+                var connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type);
+                switch (service.Type)
                 {
-                    if (lightningCharge.CookieFilePath != "fake")
-                        vm.APIToken = await System.IO.File.ReadAllTextAsync(lightningCharge.CookieFilePath);
-                    else
-                        vm.APIToken = "fake";
+                    case ExternalServiceTypes.Charge:
+                        return LightningChargeServices(service, connectionString, showQR);
+                    case ExternalServiceTypes.RTL:
+                    case ExternalServiceTypes.Spark:
+                        if (connectionString.AccessKey == null)
+                        {
+                            StatusMessage = $"Error: The access key of the service is not set";
+                            return RedirectToAction(nameof(Services));
+                        }
+                        LightningWalletServices vm = new LightningWalletServices();
+                        vm.ShowQR = showQR;
+                        vm.WalletName = service.DisplayName;
+                        vm.ServiceLink = $"{connectionString.Server}?access-key={connectionString.AccessKey}";
+                        return View("LightningWalletServices", vm);
+                    case ExternalServiceTypes.LNDGRPC:
+                    case ExternalServiceTypes.LNDRest:
+                        return LndServices(service, connectionString, nonce);
+                    default:
+                        throw new NotSupportedException(service.Type.ToString());
                 }
-                var builder = new UriBuilder(lightningCharge.ToUri(false));
-                builder.UserName = "api-token";
-                builder.Password = vm.APIToken;
-                vm.AuthenticatedUri = builder.ToString();
             }
             catch (Exception ex)
             {
                 StatusMessage = $"Error: {ex.Message}";
                 return RedirectToAction(nameof(Services));
             }
-            return View(vm);
         }
 
-        [Route("server/services/spark/{cryptoCode}/{index}")]
-        public async Task<IActionResult> SparkServices(string cryptoCode, int index, bool showQR = false)
+        private IActionResult LightningChargeServices(ExternalService service, ExternalConnectionString connectionString, bool showQR = false)
         {
-            if (!_dashBoard.IsFullySynched(cryptoCode, out var unusud))
-            {
-                StatusMessage = $"Error: {cryptoCode} is not fully synched";
-                return RedirectToAction(nameof(Services));
-            }
-            var spark = _Options.ExternalServicesByCryptoCode.GetServices<ExternalSpark>(cryptoCode).Select(c => c.ConnectionString).FirstOrDefault();
-            if(spark == null)
-            {
-                return NotFound();
-            }
-
-            SparkServicesViewModel vm = new SparkServicesViewModel();
-            vm.ShowQR = showQR;
-            try
-            {
-                var cookie = (spark.CookeFile == "fake"
-                            ? "fake:fake:fake" // If we are testing, it should not crash
-                            : await System.IO.File.ReadAllTextAsync(spark.CookeFile)).Split(':');
-                if (cookie.Length >= 3)
-                {
-                    vm.SparkLink = $"{spark.Server.AbsoluteUri}?access-key={cookie[2]}";
-                }
-            }
-            catch(Exception ex)
-            {
-                StatusMessage = $"Error: {ex.Message}";
-                return RedirectToAction(nameof(Services));
-            }
-            return View(vm);
+            ChargeServiceViewModel vm = new ChargeServiceViewModel();
+            vm.Uri = connectionString.Server.AbsoluteUri;
+            vm.APIToken = connectionString.APIToken;
+            var builder = new UriBuilder(connectionString.Server);
+            builder.UserName = "api-token";
+            builder.Password = vm.APIToken;
+            vm.AuthenticatedUri = builder.ToString();
+            return View(nameof(LightningChargeServices), vm);
         }
 
-        [Route("server/services/lnd/{cryptoCode}/{index}")]
-        public async Task<IActionResult> LndServices(string cryptoCode, int index, uint? nonce)
+        private IActionResult LndServices(ExternalService service, ExternalConnectionString connectionString, uint? nonce)
         {
-            if (!_dashBoard.IsFullySynched(cryptoCode, out var unusud))
-            {
-                StatusMessage = $"Error: {cryptoCode} is not fully synched";
-                return RedirectToAction(nameof(Services));
-            }
-            var external = GetExternalLndConnectionString(cryptoCode, index);
-            if (external == null)
-                return NotFound();
             var model = new LndGrpcServicesViewModel();
-            if (external.ConnectionType == LightningConnectionType.LndGRPC)
+            if (service.Type == ExternalServiceTypes.LNDGRPC)
             {
-                model.Host = $"{external.BaseUri.DnsSafeHost}:{external.BaseUri.Port}";
-                model.SSL = external.BaseUri.Scheme == "https";
+                model.Host = $"{connectionString.Server.DnsSafeHost}:{connectionString.Server.Port}";
+                model.SSL = connectionString.Server.Scheme == "https";
                 model.ConnectionType = "GRPC";
                 model.GRPCSSLCipherSuites = "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256";
             }
-            else if(external.ConnectionType == LightningConnectionType.LndREST)
+            else if (service.Type == ExternalServiceTypes.LNDRest)
             {
-                model.Uri = external.BaseUri.AbsoluteUri;
+                model.Uri = connectionString.Server.AbsoluteUri;
                 model.ConnectionType = "REST";
             }
 
-            if (external.CertificateThumbprint != null)
+            if (connectionString.CertificateThumbprint != null)
             {
-                model.CertificateThumbprint = Encoders.Hex.EncodeData(external.CertificateThumbprint);
+                model.CertificateThumbprint = connectionString.CertificateThumbprint;
             }
-            if (external.Macaroon != null)
+            if (connectionString.Macaroon != null)
             {
-                model.Macaroon = Encoders.Hex.EncodeData(external.Macaroon);
+                model.Macaroon = Encoders.Hex.EncodeData(connectionString.Macaroon);
             }
-            var macaroons = external.MacaroonDirectoryPath == null ? null : await Macaroons.GetFromDirectoryAsync(external.MacaroonDirectoryPath);
-            model.AdminMacaroon = macaroons?.AdminMacaroon?.Hex;
-            model.InvoiceMacaroon = macaroons?.InvoiceMacaroon?.Hex;
-            model.ReadonlyMacaroon = macaroons?.ReadonlyMacaroon?.Hex;
+            model.AdminMacaroon = connectionString.Macaroons?.AdminMacaroon?.Hex;
+            model.InvoiceMacaroon = connectionString.Macaroons?.InvoiceMacaroon?.Hex;
+            model.ReadonlyMacaroon = connectionString.Macaroons?.ReadonlyMacaroon?.Hex;
 
             if (nonce != null)
             {
-                var configKey = GetConfigKey("lnd", cryptoCode, index, nonce.Value);
+                var configKey = GetConfigKey("lnd", service.ServiceName, service.CryptoCode, nonce.Value);
                 var lnConfig = _LnConfigProvider.GetConfig(configKey);
                 if (lnConfig != null)
                 {
-                    model.QRCodeLink = $"{this.Request.GetAbsoluteRoot().WithTrailingSlash()}lnd-config/{configKey}/lnd.config";
+                    model.QRCodeLink = Request.GetAbsoluteUri(Url.Action(nameof(GetLNDConfig), new { configKey = configKey }));
                     model.QRCode = $"config={model.QRCodeLink}";
                 }
             }
 
-            return View(model);
+            return View(nameof(LndServices), model);
         }
 
-        private static uint GetConfigKey(string type, string cryptoCode, int index, uint nonce)
+        private static uint GetConfigKey(string type, string serviceName, string cryptoCode, uint nonce)
         {
-            return (uint)HashCode.Combine(type, cryptoCode, index, nonce);
+            return (uint)HashCode.Combine(type, serviceName, cryptoCode, nonce);
         }
 
         [Route("lnd-config/{configKey}/lnd.config")]
@@ -626,68 +646,62 @@ namespace BTCPayServer.Controllers
             return Json(conf);
         }
 
-        [Route("server/services/lnd/{cryptoCode}/{index}")]
+        [Route("server/services/{serviceName}/{cryptoCode}")]
         [HttpPost]
-        public async Task<IActionResult> LndServicesPost(string cryptoCode, int index)
+        public async Task<IActionResult> ServicePost(string serviceName, string cryptoCode)
         {
-            var external = GetExternalLndConnectionString(cryptoCode, index);
-            if (external == null)
+            if (!_dashBoard.IsFullySynched(cryptoCode, out var unusud))
+            {
+                StatusMessage = $"Error: {cryptoCode} is not fully synched";
+                return RedirectToAction(nameof(Services));
+            }
+            var service = _Options.ExternalServices.GetService(serviceName, cryptoCode);
+            if (service == null)
                 return NotFound();
+
+            ExternalConnectionString connectionString = null;
+            try
+            {
+                connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type);
+            }
+            catch (Exception ex)
+            {
+                StatusMessage = $"Error: {ex.Message}";
+                return RedirectToAction(nameof(Services));
+            }
+
             LightningConfigurations confs = new LightningConfigurations();
-            var macaroons = external.MacaroonDirectoryPath == null ? null : await Macaroons.GetFromDirectoryAsync(external.MacaroonDirectoryPath);
-            if (external.ConnectionType == LightningConnectionType.LndGRPC)
+            if (service.Type == ExternalServiceTypes.LNDGRPC)
             {
                 LightningConfiguration grpcConf = new LightningConfiguration();
                 grpcConf.Type = "grpc";
-                grpcConf.Host = external.BaseUri.DnsSafeHost;
-                grpcConf.Port = external.BaseUri.Port;
-                grpcConf.SSL = external.BaseUri.Scheme == "https";
+                grpcConf.Host = connectionString.Server.DnsSafeHost;
+                grpcConf.Port = connectionString.Server.Port;
+                grpcConf.SSL = connectionString.Server.Scheme == "https";
                 confs.Configurations.Add(grpcConf);
             }
-            else if (external.ConnectionType == LightningConnectionType.LndREST)
+            else if (service.Type == ExternalServiceTypes.LNDRest)
             {
                 var restconf = new LNDRestConfiguration();
                 restconf.Type = "lnd-rest";
-                restconf.Uri = external.BaseUri.AbsoluteUri;
+                restconf.Uri = connectionString.Server.AbsoluteUri;
                 confs.Configurations.Add(restconf);
             }
             else
-                throw new NotSupportedException(external.ConnectionType.ToString());
+                throw new NotSupportedException(service.Type.ToString());
             var commonConf = (LNDConfiguration)confs.Configurations[confs.Configurations.Count - 1];
             commonConf.ChainType = _Options.NetworkType.ToString();
             commonConf.CryptoCode = cryptoCode;
-            commonConf.Macaroon = external.Macaroon == null ? null : Encoders.Hex.EncodeData(external.Macaroon);
-            commonConf.CertificateThumbprint = external.CertificateThumbprint == null ? null : Encoders.Hex.EncodeData(external.CertificateThumbprint);
-            commonConf.AdminMacaroon = macaroons?.AdminMacaroon?.Hex;
-            commonConf.ReadonlyMacaroon = macaroons?.ReadonlyMacaroon?.Hex;
-            commonConf.InvoiceMacaroon = macaroons?.InvoiceMacaroon?.Hex;
+            commonConf.Macaroon = connectionString.Macaroon == null ? null : Encoders.Hex.EncodeData(connectionString.Macaroon);
+            commonConf.CertificateThumbprint = connectionString.CertificateThumbprint == null ? null : connectionString.CertificateThumbprint;
+            commonConf.AdminMacaroon = connectionString.Macaroons?.AdminMacaroon?.Hex;
+            commonConf.ReadonlyMacaroon = connectionString.Macaroons?.ReadonlyMacaroon?.Hex;
+            commonConf.InvoiceMacaroon = connectionString.Macaroons?.InvoiceMacaroon?.Hex;
 
             var nonce = RandomUtils.GetUInt32();
-            var configKey = GetConfigKey("lnd", cryptoCode, index, nonce);
+            var configKey = GetConfigKey("lnd", serviceName, cryptoCode, nonce);
             _LnConfigProvider.KeepConfig(configKey, confs);
-            return RedirectToAction(nameof(LndServices), new { cryptoCode = cryptoCode, nonce = nonce });
-        }
-
-        private LightningConnectionString GetExternalLndConnectionString(string cryptoCode, int index)
-        {
-            var connectionString = _Options.ExternalServicesByCryptoCode.GetServices<ExternalLnd>(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
-                {
-                    Logs.Configuration.LogWarning($"{cryptoCode}: The macaroon file path of the external LND grpc config was not found ({connectionString.MacaroonFilePath})");
-                    return null;
-                }
-            }
-            return connectionString;
+            return RedirectToAction(nameof(Service), new { cryptoCode = cryptoCode, serviceName = serviceName, nonce = nonce });
         }
 
         [Route("server/services/ssh")]
@@ -702,9 +716,11 @@ namespace BTCPayServer.Controllers
                     return NotFound();
                 return File(System.IO.File.ReadAllBytes(settings.KeyFile), "application/octet-stream", "id_rsa");
             }
+
+            var server = Extensions.IsLocalNetwork(settings.Server) ? this.Request.Host.Host : settings.Server;
             SSHServiceViewModel vm = new SSHServiceViewModel();
             string port = settings.Port == 22 ? "" : $" -p {settings.Port}";
-            vm.CommandLine = $"ssh {settings.Username}@{settings.Server}{port}";
+            vm.CommandLine = $"ssh {settings.Username}@{server}{port}";
             vm.Password = settings.Password;
             vm.KeyFilePassword = settings.KeyFilePassword;
             vm.HasKeyFile = !string.IsNullOrEmpty(settings.KeyFile);
@@ -726,19 +742,28 @@ namespace BTCPayServer.Controllers
             return View(settings);
         }
 
+
+        [Route("server/emails")]
+        public async Task<IActionResult> Emails()
+        {
+            var data = (await _SettingsRepository.GetSettingAsync<EmailSettings>()) ?? new EmailSettings();
+            return View(new EmailsViewModel() { Settings = data });
+        }
+
         [Route("server/emails")]
         [HttpPost]
         public async Task<IActionResult> Emails(EmailsViewModel model, string command)
         {
+            if (!model.Settings.IsComplete())
+            {
+                model.StatusMessage = "Error: Required fields missing";
+                return View(model);
+            }
+
             if (command == "Test")
             {
                 try
                 {
-                    if (!model.Settings.IsComplete())
-                    {
-                        model.StatusMessage = "Error: Required fields missing";
-                        return View(model);
-                    }
                     var client = model.Settings.CreateSmtpClient();
                     await client.SendMailAsync(model.Settings.From, model.TestEmail, "BTCPay test", "BTCPay test");
                     model.StatusMessage = "Email sent to " + model.TestEmail + ", please, verify you received it";
@@ -792,7 +817,8 @@ namespace BTCPayServer.Controllers
                     .ToList();
                 vm.LogFileOffset = offset;
 
-                if (string.IsNullOrEmpty(file)) return View("Logs", vm);
+                if (string.IsNullOrEmpty(file))
+                    return View("Logs", vm);
                 vm.Log = "";
                 var path = Path.Combine(di.FullName, file);
                 try

BTCPayServer/Controllers/StoresController.Changelly.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Net.Http;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Models.StoreViewModels;
@@ -77,7 +78,7 @@ namespace BTCPayServer.Controllers
                 case "test":
                     try
                     {
-                        var client = new Changelly(_httpClientFactory, changellySettings.ApiKey, changellySettings.ApiSecret,
+                        var client = new Changelly(_httpClientFactory.CreateClient(), changellySettings.ApiKey, changellySettings.ApiSecret,
                             changellySettings.ApiUrl);
                         var result = await client.GetCurrenciesFull();
                         vm.StatusMessage = "Test Successful";

BTCPayServer/Controllers/StoresController.CoinSwitch.cs

@@ -28,6 +28,7 @@ namespace BTCPayServer.Controllers
             vm.MerchantId = existing.MerchantId;
             vm.Enabled = existing.Enabled;
             vm.Mode = existing.Mode;
+            vm.AmountMarkupPercentage = existing.AmountMarkupPercentage;
         }
 
         [HttpPost]
@@ -50,7 +51,8 @@ namespace BTCPayServer.Controllers
             {
                 MerchantId =  vm.MerchantId,
                 Enabled = vm.Enabled,
-                Mode = vm.Mode
+                Mode = vm.Mode,
+                AmountMarkupPercentage = vm.AmountMarkupPercentage
             };
             
             switch (command)

BTCPayServer/Controllers/StoresController.LightningLike.cs

@@ -155,7 +155,7 @@ namespace BTCPayServer.Controllers
                     var handler = (LightningLikePaymentHandler)_ServiceProvider.GetRequiredService<IPaymentMethodHandler<Payments.Lightning.LightningSupportedPaymentMethod>>();
                     try
                     {
-                        var info = await handler.GetNodeInfo(paymentMethod, network);
+                        var info = await handler.GetNodeInfo(this.Request.IsOnion(), paymentMethod, network);
                         if (!vm.SkipPortTest)
                         {
                             using (CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(20)))

BTCPayServer/Controllers/StoresController.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Authentication;
 using BTCPayServer.Configuration;
@@ -188,24 +189,39 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [Route("{storeId}/rates")]
-        public IActionResult Rates()
+        public IActionResult Rates(string storeId)
         {
             var storeBlob = StoreData.GetStoreBlob();
             var vm = new RatesViewModel();
             vm.SetExchangeRates(GetSupportedExchanges(), storeBlob.PreferredExchange ?? CoinAverageRateProvider.CoinAverageName);
             vm.Spread = (double)(storeBlob.Spread * 100m);
+            vm.StoreId = storeId;
             vm.Script = storeBlob.GetRateRules(_NetworkProvider).ToString();
             vm.DefaultScript = storeBlob.GetDefaultRateRules(_NetworkProvider).ToString();
             vm.AvailableExchanges = GetSupportedExchanges();
+            vm.DefaultCurrencyPairs = storeBlob.GetDefaultCurrencyPairString();
             vm.ShowScripting = storeBlob.RateScripting;
             return View(vm);
         }
 
         [HttpPost]
         [Route("{storeId}/rates")]
-        public async Task<IActionResult> Rates(RatesViewModel model, string command = null)
+        public async Task<IActionResult> Rates(RatesViewModel model, string command = null, string storeId = null, CancellationToken cancellationToken = default)
         {
             model.SetExchangeRates(GetSupportedExchanges(), model.PreferredExchange);
+            model.StoreId = storeId ?? model.StoreId;
+            CurrencyPair[] currencyPairs = null;
+            try
+            {
+                currencyPairs = model.DefaultCurrencyPairs?
+                     .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                     .Select(p => CurrencyPair.Parse(p))
+                     .ToArray();
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(model.DefaultCurrencyPairs), "Invalid currency pairs (should be for example: BTC_USD,BTC_CAD,BTC_JPY)");
+            }
             if (!ModelState.IsValid)
             {
                 return View(model);
@@ -219,7 +235,7 @@ namespace BTCPayServer.Controllers
 
             blob.PreferredExchange = model.PreferredExchange;
             blob.Spread = (decimal)model.Spread / 100.0m;
-
+            blob.DefaultCurrencyPairs = currencyPairs;
             if (!model.ShowScripting)
             {
                 if (!GetSupportedExchanges().Select(c => c.Name).Contains(blob.PreferredExchange, StringComparer.OrdinalIgnoreCase))
@@ -267,7 +283,7 @@ namespace BTCPayServer.Controllers
                     pairs.Add(currencyPair);
                 }
 
-                var fetchs = _RateFactory.FetchRates(pairs.ToHashSet(), rules);
+                var fetchs = _RateFactory.FetchRates(pairs.ToHashSet(), rules, cancellationToken);
                 var testResults = new List<RatesViewModel.TestResultViewModel>();
                 foreach (var fetch in fetchs)
                 {
@@ -332,13 +348,15 @@ namespace BTCPayServer.Controllers
             var storeBlob = StoreData.GetStoreBlob();
             var vm = new CheckoutExperienceViewModel();
             SetCryptoCurrencies(vm, StoreData);
-            vm.SetLanguages(_LangService, storeBlob.DefaultLang);
-            vm.LightningMaxValue = storeBlob.LightningMaxValue?.ToString() ?? "";
-            vm.OnChainMinValue = storeBlob.OnChainMinValue?.ToString() ?? "";
-            vm.RequiresRefundEmail = storeBlob.RequiresRefundEmail;
             vm.CustomCSS = storeBlob.CustomCSS?.AbsoluteUri;
             vm.CustomLogo = storeBlob.CustomLogo?.AbsoluteUri;
             vm.HtmlTitle = storeBlob.HtmlTitle;
+            vm.SetLanguages(_LangService, storeBlob.DefaultLang);
+            vm.RequiresRefundEmail = storeBlob.RequiresRefundEmail;
+            vm.OnChainMinValue = storeBlob.OnChainMinValue?.ToString() ?? "";
+            vm.LightningMaxValue = storeBlob.LightningMaxValue?.ToString() ?? "";
+            vm.LightningAmountInSatoshi = storeBlob.LightningAmountInSatoshi;
+            vm.RedirectAutomatically = storeBlob.RedirectAutomatically;
             return View(vm);
         }
         void SetCryptoCurrencies(CheckoutExperienceViewModel vm, Data.StoreData storeData)
@@ -395,13 +413,15 @@ namespace BTCPayServer.Controllers
             {
                 return View(model);
             }
-            blob.DefaultLang = model.DefaultLang;
-            blob.RequiresRefundEmail = model.RequiresRefundEmail;
-            blob.LightningMaxValue = lightningMaxValue;
-            blob.OnChainMinValue = onchainMinValue;
             blob.CustomLogo = string.IsNullOrWhiteSpace(model.CustomLogo) ? null : new Uri(model.CustomLogo, UriKind.Absolute);
             blob.CustomCSS = string.IsNullOrWhiteSpace(model.CustomCSS) ? null : new Uri(model.CustomCSS, UriKind.Absolute);
             blob.HtmlTitle = string.IsNullOrWhiteSpace(model.HtmlTitle) ? null : model.HtmlTitle;
+            blob.DefaultLang = model.DefaultLang;
+            blob.RequiresRefundEmail = model.RequiresRefundEmail;
+            blob.OnChainMinValue = onchainMinValue;
+            blob.LightningMaxValue = lightningMaxValue;
+            blob.LightningAmountInSatoshi = model.LightningAmountInSatoshi;
+            blob.RedirectAutomatically = model.RedirectAutomatically;
             if (StoreData.SetStoreBlob(blob))
             {
                 needUpdate = true;
@@ -489,7 +509,7 @@ namespace BTCPayServer.Controllers
                 Action = nameof(UpdateChangellySettings),
                 Provider = "Changelly"
             });
-            
+
             var coinSwitchEnabled = storeBlob.CoinSwitchSettings != null && storeBlob.CoinSwitchSettings.Enabled;
             vm.ThirdPartyPaymentMethods.Add(new StoreViewModel.ThirdPartyPaymentMethod()
             {
@@ -593,7 +613,6 @@ namespace BTCPayServer.Controllers
             model.StoreNotConfigured = StoreNotConfigured;
             model.Tokens = tokens.Select(t => new TokenViewModel()
             {
-                Facade = t.Facade,
                 Label = t.Label,
                 SIN = t.SIN,
                 Id = t.Value
@@ -678,7 +697,6 @@ namespace BTCPayServer.Controllers
 
             var tokenRequest = new TokenRequest()
             {
-                Facade = model.Facade,
                 Label = model.Label,
                 Id = model.PublicKey == null ? null : NBitpayClient.Extensions.BitIdExtensions.GetBitIDSIN(new PubKey(model.PublicKey))
             };
@@ -690,7 +708,6 @@ namespace BTCPayServer.Controllers
                 await _TokenRepository.UpdatePairingCode(new PairingCodeEntity()
                 {
                     Id = tokenRequest.PairingCode,
-                    Facade = model.Facade,
                     Label = model.Label,
                 });
                 await _TokenRepository.PairWithStoreAsync(tokenRequest.PairingCode, storeId);
@@ -730,7 +747,6 @@ namespace BTCPayServer.Controllers
                 }
             }
             var model = new CreateTokenViewModel();
-            model.Facade = "merchant";
             ViewBag.HidePublicKey = storeId == null;
             ViewBag.ShowStores = storeId == null;
             ViewBag.ShowMenu = storeId != null;
@@ -782,7 +798,6 @@ namespace BTCPayServer.Controllers
                 return View(new PairingModel()
                 {
                     Id = pairing.Id,
-                    Facade = pairing.Facade,
                     Label = pairing.Label,
                     SIN = pairing.SIN ?? "Server-Initiated Pairing",
                     SelectedStore = selectedStore ?? stores.FirstOrDefault()?.Id,
@@ -873,7 +888,11 @@ namespace BTCPayServer.Controllers
                 ButtonSize = 2,
                 UrlRoot = appUrl,
                 PayButtonImageUrl = appUrl + "img/paybutton/pay.png",
-                StoreId = store.Id
+                StoreId = store.Id,
+                ButtonType = 0,
+                Min = 1,
+                Max = 20,
+                Step = 1
             };
             return View(model);
         }

BTCPayServer/Controllers/WalletsController.cs

@@ -181,7 +181,7 @@ namespace BTCPayServer.Controllers
                 try
                 {
                     cts.CancelAfter(TimeSpan.FromSeconds(5));
-                    var result = await RateFetcher.FetchRate(currencyPair, rateRules).WithCancellation(cts.Token);
+                    var result = await RateFetcher.FetchRate(currencyPair, rateRules, cts.Token).WithCancellation(cts.Token);
                     if (result.BidAsk != null)
                     {
                         model.Rate = result.BidAsk.Center;

BTCPayServer/Crowdfund/CrowdfundHubStreamer.cs

@@ -1,371 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Controllers;
-using BTCPayServer.Data;
-using BTCPayServer.Events;
-using BTCPayServer.Hubs;
-using BTCPayServer.Models.AppViewModels;
-using BTCPayServer.Payments;
-using BTCPayServer.Rating;
-using BTCPayServer.Services.Apps;
-using BTCPayServer.Services.Invoices;
-using BTCPayServer.Services.Rates;
-using Microsoft.AspNetCore.SignalR;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using NBitcoin;
-
-namespace BTCPayServer.Crowdfund
-{
-    public class CrowdfundHubStreamer: IDisposable
-    {
-        public const string CrowdfundInvoiceOrderIdPrefix = "crowdfund-app_";
-        private readonly EventAggregator _EventAggregator;
-        private readonly IHubContext<CrowdfundHub> _HubContext;
-        private readonly IMemoryCache _MemoryCache;
-        private readonly AppsHelper _AppsHelper;
-        private readonly RateFetcher _RateFetcher;
-        private readonly BTCPayNetworkProvider _BtcPayNetworkProvider;
-        private readonly InvoiceRepository _InvoiceRepository;
-        private readonly ILogger<CrowdfundHubStreamer> _Logger;
-
-        private readonly ConcurrentDictionary<string,(string appId, bool useAllStoreInvoices,bool useInvoiceAmount)> _QuickAppInvoiceLookup = 
-            new ConcurrentDictionary<string, (string appId, bool useAllStoreInvoices, bool useInvoiceAmount)>();
-
-        private List<IEventAggregatorSubscription> _Subscriptions;
-
-        public CrowdfundHubStreamer(EventAggregator eventAggregator, 
-            IHubContext<CrowdfundHub> hubContext, 
-            IMemoryCache memoryCache,
-            AppsHelper appsHelper, 
-            RateFetcher rateFetcher,
-            BTCPayNetworkProvider btcPayNetworkProvider,
-            InvoiceRepository invoiceRepository,
-            ILogger<CrowdfundHubStreamer> logger)
-        {
-            _EventAggregator = eventAggregator;
-            _HubContext = hubContext;
-            _MemoryCache = memoryCache;
-            _AppsHelper = appsHelper;
-            _RateFetcher = rateFetcher;
-            _BtcPayNetworkProvider = btcPayNetworkProvider;
-            _InvoiceRepository = invoiceRepository;
-            _Logger = logger;
-#pragma warning disable 4014
-            InitLookup();
-#pragma warning restore 4014
-            SubscribeToEvents();
-        }
-
-        private async Task InitLookup()
-        {
-          var apps =  await _AppsHelper.GetAllApps(null, true);
-          apps = apps.Where(model => Enum.Parse<AppType>(model.AppType) == AppType.Crowdfund).ToArray();
-          var tasks = new List<Task>();
-          tasks.AddRange(apps.Select(app => Task.Run(async () =>
-          {
-              var fullApp = await _AppsHelper.GetApp(app.Id, AppType.Crowdfund, false);
-              var settings = fullApp.GetSettings<AppsController.CrowdfundSettings>();
-              UpdateLookup(app.Id, app.StoreId, settings);
-          })));
-          await Task.WhenAll(tasks);
-        }
-
-        private void UpdateLookup(string appId, string storeId, AppsController.CrowdfundSettings settings)
-        {
-            _QuickAppInvoiceLookup.AddOrReplace(storeId,
-                (
-                    appId: appId,
-                    useAllStoreInvoices: settings?.UseAllStoreInvoices ?? false,
-                    useInvoiceAmount: settings?.UseInvoiceAmount ?? false
-                ));
-        }
-
-        public Task<ViewCrowdfundViewModel> GetCrowdfundInfo(string appId)
-        {
-            return _MemoryCache.GetOrCreateAsync(GetCacheKey(appId), async entry =>
-            {           
-                _Logger.LogInformation($"GetCrowdfundInfo {appId}");
-                var app = await _AppsHelper.GetApp(appId, AppType.Crowdfund, true);
-                var result = await GetInfo(app);
-                entry.SetValue(result);
-                
-                TimeSpan? expire = null;
-
-                if (result.StartDate.HasValue && result.StartDate < DateTime.Now)
-                {
-                    expire = result.StartDate.Value.Subtract(DateTime.Now);
-                }
-                else if (result.EndDate.HasValue && result.EndDate > DateTime.Now)
-                {
-                    expire = result.EndDate.Value.Subtract(DateTime.Now);
-                }
-                if(!expire.HasValue || expire?.TotalMinutes > 5 ||  expire?.TotalMilliseconds <= 0)
-                {
-                    expire = TimeSpan.FromMinutes(5);
-                }
-
-                entry.AbsoluteExpirationRelativeToNow = expire;
-                return result;
-            });
-        }
-
-        private void SubscribeToEvents()
-        {
-            _Subscriptions = new List<IEventAggregatorSubscription>()
-            {
-                _EventAggregator.Subscribe<InvoiceEvent>(OnInvoiceEvent),
-                _EventAggregator.Subscribe<AppsController.CrowdfundAppUpdated>(updated =>
-                {
-                    UpdateLookup(updated.AppId, updated.StoreId, updated.Settings);
-                    InvalidateCacheForApp(updated.AppId);
-                })
-            };
-        }
-
-        private string GetCacheKey(string appId)
-        {
-            return $"{CrowdfundInvoiceOrderIdPrefix}:{appId}";
-        }
-
-        private void OnInvoiceEvent(InvoiceEvent invoiceEvent)
-        {
-            if (!_QuickAppInvoiceLookup.TryGetValue(invoiceEvent.Invoice.StoreId, out var quickLookup) ||
-                (!quickLookup.useAllStoreInvoices && 
-                 !string.IsNullOrEmpty(invoiceEvent.Invoice.OrderId) &&
-                !invoiceEvent.Invoice.OrderId.Equals($"{CrowdfundInvoiceOrderIdPrefix}{quickLookup.appId}", StringComparison.InvariantCulture)
-                ))
-            {
-                return;
-            }
-            
-            switch (invoiceEvent.Name)
-            {
-                case InvoiceEvent.ReceivedPayment:
-                    var data = invoiceEvent.Payment.GetCryptoPaymentData();
-                    _HubContext.Clients.Group(quickLookup.appId).SendCoreAsync(CrowdfundHub.PaymentReceived, new object[]
-                    {
-                        data.GetValue(), 
-                        invoiceEvent.Payment.GetCryptoCode(), 
-                        Enum.GetName(typeof(PaymentTypes), 
-                            invoiceEvent.Payment.GetPaymentMethodId().PaymentType)
-                    } );
-                    _Logger.LogInformation($"App {quickLookup.appId}: Received Payment");
-                    InvalidateCacheForApp(quickLookup.appId);
-                    break;
-                case InvoiceEvent.Created:
-                case InvoiceEvent.MarkedInvalid:
-                case InvoiceEvent.MarkedCompleted:
-                    if (quickLookup.useInvoiceAmount)
-                    {
-                        InvalidateCacheForApp(quickLookup.appId);
-                    }
-                    break;
-                case InvoiceEvent.Completed:
-                    InvalidateCacheForApp(quickLookup.appId);
-                    break;
-            }
-        }
-
-        private void InvalidateCacheForApp(string appId)
-        {
-            _Logger.LogInformation($"App {appId} cache invalidated");
-            _MemoryCache.Remove(GetCacheKey(appId));
-
-            GetCrowdfundInfo(appId).ContinueWith(task =>
-            {
-                _HubContext.Clients.Group(appId).SendCoreAsync(CrowdfundHub.InfoUpdated, new object[]{ task.Result} );
-            }, TaskScheduler.Current);
-            
-        }
-        
-        private async Task<decimal> GetCurrentContributionAmount(Dictionary<string, decimal> stats, string primaryCurrency, RateRules rateRules)
-        {
-            decimal result = 0;
-
-            var ratesTask = _RateFetcher .FetchRates(
-                stats.Keys
-                    .Select((x) => new CurrencyPair( primaryCurrency, PaymentMethodId.Parse(x).CryptoCode))
-                    .Distinct()
-                    .ToHashSet(), 
-                rateRules);
-
-            var finalTasks = new List<Task>();
-            foreach (var rateTask in ratesTask)
-            {
-                finalTasks.Add(Task.Run(async () =>
-                {
-                    var tResult = await rateTask.Value;
-                    var rate = tResult.BidAsk?.Bid;
-                    if (rate == null) return;
-
-                    foreach (var stat in stats)
-                    {
-                        if (string.Equals(PaymentMethodId.Parse(stat.Key).CryptoCode, rateTask.Key.Right,
-                            StringComparison.InvariantCultureIgnoreCase))
-                        {
-                            result += (1m / rate.Value) *  stat.Value;
-                        }
-                    }
-                }));
-            }
-
-            await Task.WhenAll(finalTasks);
-
-            return result;
-        }
-        
-        private static Dictionary<string, decimal> GetCurrentContributionAmountStats(InvoiceEntity[] invoices, bool usePaymentData = true)
-        {
-            if(usePaymentData){
-            var payments = invoices.SelectMany(entity => entity.GetPayments());
-
-            var groupedByMethod = payments.GroupBy(entity => entity.GetPaymentMethodId());
-
-            return groupedByMethod.ToDictionary(entities => entities.Key.ToString(),
-                entities => entities.Sum(entity => entity.GetCryptoPaymentData().GetValue()));
-            }
-            else
-            {
-                return invoices
-                    .GroupBy(entity => entity.ProductInformation.Currency)
-                    .ToDictionary(
-                        entities => entities.Key,
-                        entities => entities.Sum(entity => entity.ProductInformation.Price));
-            }
-        }
-        private async Task<ViewCrowdfundViewModel> GetInfo(AppData appData, string statusMessage= null)
-        {
-            var settings = appData.GetSettings<AppsController.CrowdfundSettings>();
-
-            var resetEvery = settings.StartDate.HasValue? settings.ResetEvery : CrowdfundResetEvery.Never;
-            DateTime? lastResetDate = null;
-            DateTime? nextResetDate = null;
-            if (resetEvery != CrowdfundResetEvery.Never)
-            {
-                lastResetDate = settings.StartDate.Value;
-                
-                nextResetDate = lastResetDate.Value;
-                while (DateTime.Now >= nextResetDate)
-                {
-                    lastResetDate = nextResetDate;
-                    switch (resetEvery)
-                    {
-                        case CrowdfundResetEvery.Hour:
-                            nextResetDate = lastResetDate.Value.AddHours(settings.ResetEveryAmount);
-                            break;
-                        case CrowdfundResetEvery.Day:
-                            nextResetDate = lastResetDate.Value.AddDays(settings.ResetEveryAmount);
-                            break;
-                        case CrowdfundResetEvery.Month:
-
-                            nextResetDate = lastResetDate.Value.AddMonths(settings.ResetEveryAmount);
-                            break;
-                        case CrowdfundResetEvery.Year:
-                            nextResetDate = lastResetDate.Value.AddYears(settings.ResetEveryAmount);
-                            break;
-                    }
-                }
-            }
-            
-            var invoices = await GetInvoicesForApp(settings.UseAllStoreInvoices? null : appData.Id, lastResetDate);
-            var completeInvoices = invoices.Where(entity => entity.Status == InvoiceStatus.Complete).ToArray();
-            var pendingInvoices = invoices.Where(entity => entity.Status != InvoiceStatus.Complete).ToArray();
-            
-            var rateRules = appData.StoreData.GetStoreBlob().GetRateRules(_BtcPayNetworkProvider);
-            
-            var pendingPaymentStats = GetCurrentContributionAmountStats(pendingInvoices, !settings.UseInvoiceAmount);
-            var paymentStats = GetCurrentContributionAmountStats(completeInvoices, !settings.UseInvoiceAmount); 
-            
-            var currentAmount = await GetCurrentContributionAmount(
-                paymentStats,
-                settings.TargetCurrency, rateRules); 
-            var currentPendingAmount =  await GetCurrentContributionAmount(
-                pendingPaymentStats,
-                settings.TargetCurrency, rateRules);
-
-            
-            
-            
-            var perkCount = invoices
-                .Where(entity => !string.IsNullOrEmpty( entity.ProductInformation.ItemCode))
-                .GroupBy(entity => entity.ProductInformation.ItemCode)
-                .ToDictionary(entities => entities.Key, entities => entities.Count());
-
-            var perks = _AppsHelper.Parse(settings.PerksTemplate, settings.TargetCurrency);
-            if (settings.SortPerksByPopularity)
-            {
-                var  ordered = perkCount.OrderByDescending(pair => pair.Value);
-                var newPerksOrder = ordered
-                    .Select(keyValuePair => perks.SingleOrDefault(item => item.Id == keyValuePair.Key))
-                    .Where(matchingPerk => matchingPerk != null)
-                    .ToList();
-                var remainingPerks = perks.Where(item => !newPerksOrder.Contains(item));
-                newPerksOrder.AddRange(remainingPerks);
-                perks = newPerksOrder.ToArray();
-            }    
-            return new ViewCrowdfundViewModel()
-            {
-                Title = settings.Title,
-                Tagline = settings.Tagline,
-                Description = settings.Description,
-                CustomCSSLink = settings.CustomCSSLink,
-                MainImageUrl = settings.MainImageUrl,
-                EmbeddedCSS = settings.EmbeddedCSS,
-                StoreId = appData.StoreDataId,
-                AppId = appData.Id,
-                StartDate = settings.StartDate?.ToUniversalTime(), 
-                EndDate = settings.EndDate?.ToUniversalTime(),
-                TargetAmount = settings.TargetAmount,
-                TargetCurrency = settings.TargetCurrency,
-                EnforceTargetAmount = settings.EnforceTargetAmount,
-                StatusMessage = statusMessage,
-                Perks = perks,
-                DisqusEnabled = settings.DisqusEnabled,
-                SoundsEnabled = settings.SoundsEnabled,
-                DisqusShortname = settings.DisqusShortname,
-                AnimationsEnabled = settings.AnimationsEnabled,
-                ResetEveryAmount = settings.ResetEveryAmount,
-                DisplayPerksRanking = settings.DisplayPerksRanking,
-                PerkCount = perkCount,
-                ResetEvery = Enum.GetName(typeof(CrowdfundResetEvery),settings.ResetEvery),
-                CurrencyData = _AppsHelper.GetCurrencyData(settings.TargetCurrency, true),
-                Info = new ViewCrowdfundViewModel.CrowdfundInfo()
-                {
-                    TotalContributors = invoices.Length,
-                    CurrentPendingAmount = currentPendingAmount,
-                    CurrentAmount = currentAmount,
-                    ProgressPercentage =   (currentAmount/ settings.TargetAmount) * 100,
-                    PendingProgressPercentage =  ( currentPendingAmount/ settings.TargetAmount) * 100,
-                    LastUpdated = DateTime.Now,
-                    PaymentStats = paymentStats,
-                    PendingPaymentStats = pendingPaymentStats,
-                    LastResetDate = lastResetDate,
-                    NextResetDate = nextResetDate
-                }
-            };
-        }
-
-        private async Task<InvoiceEntity[]> GetInvoicesForApp(string appId, DateTime? startDate = null)
-        {
-            return await  _InvoiceRepository.GetInvoices(new InvoiceQuery()
-            {
-                OrderId = appId == null? null : new []{$"{CrowdfundInvoiceOrderIdPrefix}{appId}"},
-                Status = new string[]{
-                    InvoiceState.ToString(InvoiceStatus.New),
-                    InvoiceState.ToString(InvoiceStatus.Paid), 
-                    InvoiceState.ToString(InvoiceStatus.Confirmed), 
-                    InvoiceState.ToString(InvoiceStatus.Complete)},
-                StartDate = startDate
-            });
-        }
-
-        public void Dispose()
-        {
-            _Subscriptions.ForEach(subscription => subscription.Dispose());
-        }
-    }
-}

BTCPayServer/Data/AppData.cs

@@ -23,6 +23,7 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        public bool TagAllInvoices { get; set; }
         public string Settings { get; set; }
 
         public T GetSettings<T>() where T : class, new()

BTCPayServer/Data/ApplicationDbContext.cs

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Models;
+using BTCPayServer.Services.PaymentRequests;
 using Microsoft.EntityFrameworkCore.Infrastructure.Internal;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
@@ -54,6 +55,11 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        
+        public DbSet<PaymentRequestData> PaymentRequests
+        {
+            get; set;
+        }
 
         public DbSet<StoreData> Stores
         {
@@ -204,6 +210,15 @@ namespace BTCPayServer.Data
                     o.UniqueId
 #pragma warning restore CS0618
                 });
+            
+            
+            builder.Entity<PaymentRequestData>()
+                .HasOne(o => o.StoreData)
+                .WithMany(i => i.PaymentRequests)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.Entity<PaymentRequestData>()
+                .HasIndex(o => o.Status);
         }
     }
 }

BTCPayServer/Data/PairedSINData.cs

@@ -12,11 +12,6 @@ namespace BTCPayServer.Data
             get; set;
         }
 
-        public string Facade
-        {
-            get; set;
-        }
-
         public string StoreDataId
         {
             get; set;

BTCPayServer/Data/PairingCodeData.cs

@@ -11,7 +11,7 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
-
+        [Obsolete("Unused")]
         public string Facade
         {
             get; set;

BTCPayServer/Data/StoreData.cs

@@ -21,6 +21,7 @@ using BTCPayServer.Payments.Changelly;
 using BTCPayServer.Payments.CoinSwitch;
 using BTCPayServer.Security;
 using BTCPayServer.Rating;
+using BTCPayServer.Services.PaymentRequests;
 using BTCPayServer.Services.Mails;
 
 namespace BTCPayServer.Data
@@ -41,6 +42,11 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        
+        public List<PaymentRequestData> PaymentRequests
+        {
+            get; set;
+        }
 
         public List<InvoiceData> Invoices { get; set; }
 
@@ -301,6 +307,25 @@ namespace BTCPayServer.Data
 
         public bool RequiresRefundEmail { get; set; }
 
+        CurrencyPair[] _DefaultCurrencyPairs;
+        [JsonProperty("defaultCurrencyPairs", ItemConverterType = typeof(CurrencyPairJsonConverter))]
+        public CurrencyPair[] DefaultCurrencyPairs
+        {
+            get
+            {
+                return _DefaultCurrencyPairs ?? Array.Empty<CurrencyPair>();
+            }
+            set
+            {
+                _DefaultCurrencyPairs = value;
+            }
+        }
+
+        public string GetDefaultCurrencyPairString()
+        {
+            return string.Join(',', DefaultCurrencyPairs.Select(c => c.ToString()));
+        }
+
         public string DefaultLang { get; set; }
         [DefaultValue(60)]
         [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
@@ -324,10 +349,11 @@ namespace BTCPayServer.Data
         public List<RateRule_Obsolete> RateRules { get; set; } = new List<RateRule_Obsolete>();
         public string PreferredExchange { get; set; }
 
-        [JsonConverter(typeof(CurrencyValueJsonConverter))]
-        public CurrencyValue LightningMaxValue { get; set; }
         [JsonConverter(typeof(CurrencyValueJsonConverter))]
         public CurrencyValue OnChainMinValue { get; set; }
+        [JsonConverter(typeof(CurrencyValueJsonConverter))]
+        public CurrencyValue LightningMaxValue { get; set; }
+        public bool LightningAmountInSatoshi { get; set; }
 
         [JsonConverter(typeof(UriJsonConverter))]
         public Uri CustomLogo { get; set; }
@@ -423,6 +449,7 @@ namespace BTCPayServer.Data
         public Dictionary<string, string> WalletKeyPathRoots { get; set; } = new Dictionary<string, string>();
 
         public EmailSettings EmailSettings { get; set; }
+        public bool RedirectAutomatically { get; set; }
 
         public IPaymentFilter GetExcludedPaymentMethods()
         {

BTCPayServer/Events/InvoiceEvent.cs

@@ -20,14 +20,14 @@ namespace BTCPayServer.Events
         public const string Confirmed= "invoice_confirmed";
         public const string Completed= "invoice_completed";
         
-        public InvoiceEvent(Models.InvoiceResponse invoice, int code, string name)
+        public InvoiceEvent(InvoiceEntity invoice, int code, string name)
         {
             Invoice = invoice;
             EventCode = code;
             Name = name;
         }
 
-        public Models.InvoiceResponse Invoice { get; set; }
+        public InvoiceEntity Invoice { get; set; }
         public int EventCode { get; set; }
         public string Name { get; set; }
 

BTCPayServer/ExplorerClientProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Net.Http;
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
 using System.Linq;
@@ -17,7 +18,7 @@ namespace BTCPayServer
 
         public BTCPayNetworkProvider NetworkProviders => _NetworkProviders;
         NBXplorerDashboard _Dashboard;
-        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options, NBXplorerDashboard dashboard)
+        public ExplorerClientProvider(IHttpClientFactory httpClientFactory, BTCPayNetworkProvider networkProviders, BTCPayServerOptions options, NBXplorerDashboard dashboard)
         {
             _Dashboard = dashboard;
             _NetworkProviders = networkProviders;
@@ -32,14 +33,15 @@ namespace BTCPayServer
                 Logs.Configuration.LogInformation($"{setting.CryptoCode}: Cookie file is {(setting.CookieFile ?? "not set")}");
                 if (setting.ExplorerUri != null)
                 {
-                    _Clients.TryAdd(setting.CryptoCode, CreateExplorerClient(_NetworkProviders.GetNetwork(setting.CryptoCode), setting.ExplorerUri, setting.CookieFile));
+                    _Clients.TryAdd(setting.CryptoCode, CreateExplorerClient(httpClientFactory.CreateClient($"NBXPLORER_{setting.CryptoCode}"), _NetworkProviders.GetNetwork(setting.CryptoCode), setting.ExplorerUri, setting.CookieFile));
                 }
             }
         }
 
-        private static ExplorerClient CreateExplorerClient(BTCPayNetwork n, Uri uri, string cookieFile)
+        private static ExplorerClient CreateExplorerClient(HttpClient httpClient, BTCPayNetwork n, Uri uri, string cookieFile)
         {
             var explorer = new ExplorerClient(n.NBXplorerNetwork, uri);
+            explorer.SetClient(httpClient);
             if (cookieFile == null)
             {
                 Logs.Configuration.LogWarning($"{n.CryptoCode}: Not using cookie authentication");

BTCPayServer/Extensions.cs

@@ -33,6 +33,7 @@ using BTCPayServer.Services;
 using BTCPayServer.Data;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using NBXplorer.DerivationStrategy;
+using System.Net;
 
 namespace BTCPayServer
 {
@@ -61,6 +62,23 @@ namespace BTCPayServer
             }
             return value;
         }
+        public static decimal RoundToSignificant(this decimal value, ref int divisibility)
+        {
+            if (value != 0m)
+            {
+                while (true)
+                {
+                    var rounded = decimal.Round(value, divisibility, MidpointRounding.AwayFromZero);
+                    if ((Math.Abs(rounded - value) / value) < 0.001m)
+                    {
+                        value = rounded;
+                        break;
+                    }
+                    divisibility++;
+                }
+            }
+            return value;
+        }
         public static PaymentMethodId GetpaymentMethodId(this InvoiceCryptoInfo info)
         {
             return new PaymentMethodId(info.CryptoCode, Enum.Parse<PaymentTypes>(info.PaymentType));
@@ -108,6 +126,12 @@ namespace BTCPayServer
                 return str;
             return str + "/";
         }
+        public static string WithStartingSlash(this string str)
+        {
+            if (str.StartsWith("/", StringComparison.InvariantCulture))
+                return str;
+            return $"/{str}";
+        }
 
         public static void SetHeaderOnStarting(this HttpResponse resp, string name, string value)
         {
@@ -142,6 +166,31 @@ namespace BTCPayServer
                             (derivationStrategyBase is DirectDerivationStrategy direct) && direct.Segwit;
         }
 
+        public static bool IsLocalNetwork(string server)
+        {
+            if (server == null)
+                throw new ArgumentNullException(nameof(server));
+            if (Uri.CheckHostName(server) == UriHostNameType.Dns)
+            {
+                return server.EndsWith(".internal", StringComparison.OrdinalIgnoreCase) ||
+                   server.EndsWith(".local", StringComparison.OrdinalIgnoreCase) ||
+                   server.EndsWith(".lan", StringComparison.OrdinalIgnoreCase) ||
+                   server.IndexOf('.', StringComparison.OrdinalIgnoreCase) == -1;
+            }
+            if(IPAddress.TryParse(server, out var ip))
+            {
+                return ip.IsLocal();
+            }
+            return false;
+        }
+
+        public static bool IsOnion(this HttpRequest request)
+        {
+            if (request?.Host.Host == null)
+                return false;
+            return request.Host.Host.EndsWith(".onion", StringComparison.OrdinalIgnoreCase);
+        }
+
         public static string GetAbsoluteRoot(this HttpRequest request)
         {
             return string.Concat(
@@ -194,8 +243,10 @@ namespace BTCPayServer
         /// <returns></returns>
         public static string GetRelativePathOrAbsolute(this HttpRequest request, string path)
         {
-            if (Uri.TryCreate(path, UriKind.Absolute, out var unused))
+            if (!Uri.TryCreate(path, UriKind.RelativeOrAbsolute, out var uri) || 
+                uri.IsAbsoluteUri)
                 return path;
+
             if (path.Length > 0 && path[0] != '/')
                 path = $"/{path}";
             return string.Concat(
@@ -211,6 +262,31 @@ namespace BTCPayServer
             return isRelative ? request.GetAbsoluteRoot() + redirectUrl : redirectUrl;
         }
 
+        /// <summary>
+        /// Will return an absolute URL. 
+        /// If `relativeOrAsbolute` is absolute, returns it.
+        /// If `relativeOrAsbolute` is relative, send absolute url based on the HOST of this request (without PathBase)
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="relativeOrAbsolte"></param>
+        /// <returns></returns>
+        public static Uri GetAbsoluteUriNoPathBase(this HttpRequest request, Uri relativeOrAbsolute = null)
+        {
+            if (relativeOrAbsolute == null)
+            {
+                return new Uri(string.Concat(
+                    request.Scheme,
+                    "://",
+                    request.Host.ToUriComponent()), UriKind.Absolute);
+            }
+            if (relativeOrAbsolute.IsAbsoluteUri)
+                return relativeOrAbsolute;
+            return new Uri(string.Concat(
+                    request.Scheme,
+                    "://",
+                    request.Host.ToUriComponent()) + relativeOrAbsolute.ToString().WithStartingSlash(), UriKind.Absolute);
+        }
+
         public static IServiceCollection ConfigureBTCPayServer(this IServiceCollection services, IConfiguration conf)
         {
             services.Configure<BTCPayServerOptions>(o =>
@@ -253,30 +329,6 @@ namespace BTCPayServer
             NBitcoin.Extensions.TryAdd(ctx.Items, "BitpayAuth", value);
         }
 
-        public static async Task<T> WithCancellation<T>(this Task<T> task, CancellationToken cancellationToken)
-        {
-            using (var delayCTS = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
-            {
-                var waiting = Task.Delay(-1, delayCTS.Token);
-                var doing = task;
-                await Task.WhenAny(waiting, doing);
-                delayCTS.Cancel();
-                cancellationToken.ThrowIfCancellationRequested();
-                return await doing;
-            }
-        }
-        public static async Task WithCancellation(this Task task, CancellationToken cancellationToken)
-        {
-            using (var delayCTS = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
-            {
-                var waiting = Task.Delay(-1, delayCTS.Token);
-                var doing = task;
-                await Task.WhenAny(waiting, doing);
-                delayCTS.Cancel();
-                cancellationToken.ThrowIfCancellationRequested();
-            }
-        }
-
         public static (string Signature, String Id, String Authorization) GetBitpayAuth(this HttpContext ctx)
         {
             ctx.Items.TryGetValue("BitpayAuth", out object obj);
@@ -298,5 +350,15 @@ namespace BTCPayServer
             var res = JsonConvert.SerializeObject(o, Formatting.None, jsonSettings);
             return res;
         }
+        
+        public static string TrimEnd(this string input, string suffixToRemove,
+            StringComparison comparisonType) {
+
+            if (input != null && suffixToRemove != null
+                              && input.EndsWith(suffixToRemove, comparisonType)) {
+                return input.Substring(0, input.Length - suffixToRemove.Length);
+            }
+            else return input;
+        }
     }
 }

BTCPayServer/HostedServices/BackgroundJobSchedulerHostedService.cs

@@ -1,4 +1,5 @@
 using System;
+using NBitcoin;
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
 using System.Linq;
@@ -34,6 +35,8 @@ namespace BTCPayServer.HostedServices
 
         public async Task StopAsync(CancellationToken cancellationToken)
         {
+            if (_Stop == null)
+                return;
             _Stop.Cancel();
             try
             {
@@ -43,7 +46,14 @@ namespace BTCPayServer.HostedServices
             {
 
             }
-            await BackgroundJobClient.WaitAllRunning(cancellationToken);
+            try
+            {
+                await BackgroundJobClient.WaitAllRunning(cancellationToken);
+            }
+            catch (OperationCanceledException)
+            {
+
+            }
         }
     }
 
@@ -51,10 +61,10 @@ namespace BTCPayServer.HostedServices
     {
         class BackgroundJob
         {
-            public Func<Task> Action;
+            public Func<CancellationToken, Task> Action;
             public TimeSpan Delay;
             public IDelay DelayImplementation;
-            public BackgroundJob(Func<Task> action, TimeSpan delay, IDelay delayImplementation)
+            public BackgroundJob(Func<CancellationToken, Task> action, TimeSpan delay, IDelay delayImplementation)
             {
                 this.Action = action;
                 this.Delay = delay;
@@ -64,7 +74,7 @@ namespace BTCPayServer.HostedServices
             public async Task Run(CancellationToken cancellationToken)
             {
                 await DelayImplementation.Wait(Delay, cancellationToken);
-                await Action();
+                await Action(cancellationToken);
             }
         }
 
@@ -79,9 +89,9 @@ namespace BTCPayServer.HostedServices
 
         private Channel<BackgroundJob> _Jobs = Channel.CreateUnbounded<BackgroundJob>();
         HashSet<Task> _Processing = new HashSet<Task>();
-        public void Schedule(Func<Task> action, TimeSpan delay)
+        public void Schedule(Func<CancellationToken, Task> act, TimeSpan scheduledIn)
         {
-            _Jobs.Writer.TryWrite(new BackgroundJob(action, delay, Delay));
+            _Jobs.Writer.TryWrite(new BackgroundJob(act, scheduledIn, Delay));
         }
 
         public async Task WaitAllRunning(CancellationToken cancellationToken)
@@ -89,6 +99,8 @@ namespace BTCPayServer.HostedServices
             Task[] processing = null;
             lock (_Processing)
             {
+                if (_Processing.Count == 0)
+                    return;
                 processing = _Processing.ToArray();
             }
 
@@ -96,9 +108,8 @@ namespace BTCPayServer.HostedServices
             {
                 await Task.WhenAll(processing).WithCancellation(cancellationToken);
             }
-            catch (Exception) when (cancellationToken.IsCancellationRequested)
+            catch (Exception) when (!cancellationToken.IsCancellationRequested)
             {
-                throw;
             }
         }
 
@@ -113,8 +124,7 @@ namespace BTCPayServer.HostedServices
                     {
                         _Processing.Add(processing);
                     }
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-                    processing.ContinueWith(t =>
+                    _ = processing.ContinueWith(t =>
                     {
                         if (t.IsFaulted)
                         {
@@ -125,7 +135,6 @@ namespace BTCPayServer.HostedServices
                             _Processing.Remove(processing);
                         }
                     }, default, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                 }
             }
         }

BTCPayServer/HostedServices/BaseAsyncService.cs

@@ -59,6 +59,8 @@ namespace BTCPayServer.HostedServices
 
         public Task StopAsync(CancellationToken cancellationToken)
         {
+            if (_Cts == null)
+                return Task.CompletedTask;
             _Cts.Cancel();
             return Task.WhenAll(_Tasks);
         }

BTCPayServer/HostedServices/CssThemeManager.cs

@@ -13,6 +13,7 @@ using BTCPayServer.Events;
 using BTCPayServer.Services;
 using Microsoft.AspNetCore.Mvc.Filters;
 using BTCPayServer.Security;
+using BTCPayServer.Services.Apps;
 
 namespace BTCPayServer.HostedServices
 {
@@ -44,11 +45,20 @@ namespace BTCPayServer.HostedServices
             get { return _creativeStartUri; }
         }
 
+
         public bool ShowRegister { get; set; }
+        public bool DiscourageSearchEngines { get; set; }
+
+        public AppType? RootAppType { get; set; }
+        public string RootAppId { get; set; }
 
         internal void Update(PoliciesSettings data)
         {
             ShowRegister = !data.LockSubscription;
+            DiscourageSearchEngines = data.DiscourageSearchEngines;
+
+            RootAppType = data.RootAppType;
+            RootAppId = data.RootAppId;
         }
     }
 

BTCPayServer/HostedServices/EventHostedServiceBase.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Hosting;
+
+namespace BTCPayServer.HostedServices
+{
+    public class EventHostedServiceBase : IHostedService
+    {
+        private readonly EventAggregator _EventAggregator;
+
+        private List<IEventAggregatorSubscription> _Subscriptions;
+        private CancellationTokenSource _Cts;
+
+        public EventHostedServiceBase(EventAggregator eventAggregator)
+        {
+            _EventAggregator = eventAggregator;
+        }
+
+        Channel<object> _Events = Channel.CreateUnbounded<object>();
+        public async Task ProcessEvents(CancellationToken cancellationToken)
+        {
+            while (await _Events.Reader.WaitToReadAsync(cancellationToken))
+            {
+                if (_Events.Reader.TryRead(out var evt))
+                {
+                    try
+                    {
+                        await ProcessEvent(evt, cancellationToken);
+                    }
+                    catch when (cancellationToken.IsCancellationRequested)
+                    {
+                        throw;
+                    }
+                    catch (Exception ex)
+                    {
+                        Logs.PayServer.LogWarning(ex, $"Unhandled exception in {this.GetType().Name}");
+                    }
+                }
+            }
+        }
+
+        protected virtual Task ProcessEvent(object evt, CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+
+        protected virtual void SubscibeToEvents()
+        {
+
+        }
+
+        protected void Subscribe<T>()
+        {
+            _Subscriptions.Add(_EventAggregator.Subscribe<T>(e => _Events.Writer.TryWrite(e)));
+        }
+
+        public virtual Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Subscriptions = new List<IEventAggregatorSubscription>();
+            SubscibeToEvents();
+            _Cts = new CancellationTokenSource();
+            _ProcessingEvents = ProcessEvents(_Cts.Token);
+            return Task.CompletedTask;
+        }
+        Task _ProcessingEvents = Task.CompletedTask;
+
+        public virtual async Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Subscriptions?.ForEach(subscription => subscription.Dispose());
+            _Cts?.Cancel();
+            try
+            {
+                await _ProcessingEvents;
+            }
+            catch (OperationCanceledException)
+            { }
+        }
+    }
+}

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -24,7 +24,7 @@ namespace BTCPayServer.HostedServices
 {
     public class InvoiceNotificationManager : IHostedService
     {
-        public static HttpClient _Client = new HttpClient();
+        HttpClient _Client;
 
         public class ScheduledJob
         {
@@ -46,6 +46,7 @@ namespace BTCPayServer.HostedServices
         private readonly EmailSenderFactory _EmailSenderFactory;
 
         public InvoiceNotificationManager(
+            IHttpClientFactory httpClientFactory,
             IBackgroundJobClient jobClient,
             EventAggregator eventAggregator,
             InvoiceRepository invoiceRepository,
@@ -53,6 +54,7 @@ namespace BTCPayServer.HostedServices
             ILogger<InvoiceNotificationManager> logger,
             EmailSenderFactory emailSenderFactory)
         {
+            _Client = httpClientFactory.CreateClient();
             _JobClient = jobClient;
             _EventAggregator = eventAggregator;
             _InvoiceRepository = invoiceRepository;
@@ -135,23 +137,29 @@ namespace BTCPayServer.HostedServices
                 return;
             var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Notification = notification });
             if (!string.IsNullOrEmpty(invoice.NotificationURL))
-                _JobClient.Schedule(() => NotifyHttp(invoiceStr), TimeSpan.Zero);
+                _JobClient.Schedule((cancellation) => NotifyHttp(invoiceStr, cancellation), TimeSpan.Zero);
         }
 
-        public async Task NotifyHttp(string invoiceData)
+        public async Task NotifyHttp(string invoiceData, CancellationToken cancellationToken)
         {
             var job = NBitcoin.JsonConverters.Serializer.ToObject<ScheduledJob>(invoiceData);
             bool reschedule = false;
             var aggregatorEvent = new InvoiceIPNEvent(job.Notification.Data.Id, job.Notification.Event.Code, job.Notification.Event.Name);
-            CancellationTokenSource cts = new CancellationTokenSource(10000);
             try
             {
-                HttpResponseMessage response = await SendNotification(job.Notification, cts.Token);
+                HttpResponseMessage response = await SendNotification(job.Notification, cancellationToken);
                 reschedule = !response.IsSuccessStatusCode;
                 aggregatorEvent.Error = reschedule ? $"Unexpected return code: {(int)response.StatusCode}" : null;
                 _EventAggregator.Publish<InvoiceIPNEvent>(aggregatorEvent);
             }
-            catch (OperationCanceledException) when (cts.IsCancellationRequested)
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                // When the JobClient will be persistent, this will reschedule the job for after reboot
+                invoiceData = NBitcoin.JsonConverters.Serializer.ToString(job);
+                _JobClient.Schedule((cancellation) => NotifyHttp(invoiceData, cancellation), TimeSpan.FromMinutes(10.0));
+                return;
+            }
+            catch (OperationCanceledException)
             {
                 aggregatorEvent.Error = "Timeout";
                 _EventAggregator.Publish<InvoiceIPNEvent>(aggregatorEvent);
@@ -172,14 +180,13 @@ namespace BTCPayServer.HostedServices
                 aggregatorEvent.Error = $"Unexpected error: {message}";
                 _EventAggregator.Publish<InvoiceIPNEvent>(aggregatorEvent);
             }
-            finally { cts?.Dispose(); }
 
             job.TryCount++;
 
             if (job.TryCount < MaxTry && reschedule)
             {
                 invoiceData = NBitcoin.JsonConverters.Serializer.ToString(job);
-                _JobClient.Schedule(() => NotifyHttp(invoiceData), TimeSpan.FromMinutes(10.0));
+                _JobClient.Schedule((cancellation) => NotifyHttp(invoiceData, cancellation), TimeSpan.FromMinutes(10.0));
             }
         }
 
@@ -203,7 +210,7 @@ namespace BTCPayServer.HostedServices
         }
 
         Encoding UTF8 = new UTF8Encoding(false);
-        private async Task<HttpResponseMessage> SendNotification(InvoicePaymentNotificationEventWrapper notification, CancellationToken cancellation)
+        private async Task<HttpResponseMessage> SendNotification(InvoicePaymentNotificationEventWrapper notification, CancellationToken cancellationToken)
         {
             var request = new HttpRequestMessage();
             request.Method = HttpMethod.Post;
@@ -224,7 +231,14 @@ namespace BTCPayServer.HostedServices
 
             request.RequestUri = new Uri(notification.NotificationURL, UriKind.Absolute);
             request.Content = new StringContent(notificationString, UTF8, "application/json");
-            var response = await Enqueue(notification.Data.Id, async () => await _Client.SendAsync(request, cancellation));
+            var response = await Enqueue(notification.Data.Id, async () =>
+            {
+                using (CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
+                {
+                    cts.CancelAfter(TimeSpan.FromMinutes(1.0));
+                    return await _Client.SendAsync(request, cts.Token);
+                }
+            });
             return response;
         }
 

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -49,7 +49,6 @@ namespace BTCPayServer.HostedServices
             InvoiceRepository invoiceRepository,
             EventAggregator eventAggregator)
         {
-            PollInterval = TimeSpan.FromMinutes(1.0);
             _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
             _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
             _NetworkProvider = networkProvider;
@@ -65,10 +64,10 @@ namespace BTCPayServer.HostedServices
                 context.MarkDirty();
                 await _InvoiceRepository.UnaffectAddress(invoice.Id);
 
-                context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1004, InvoiceEvent.Expired));
                 invoice.Status = InvoiceStatus.Expired;
-                if(invoice.ExceptionStatus == InvoiceExceptionStatus.PaidPartial)
-                    context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 2000, InvoiceEvent.ExpiredPaidPartial));
+                context.Events.Add(new InvoiceEvent(invoice, 1004, InvoiceEvent.Expired));
+                if (invoice.ExceptionStatus == InvoiceExceptionStatus.PaidPartial)
+                    context.Events.Add(new InvoiceEvent(invoice, 2000, InvoiceEvent.ExpiredPaidPartial));
             }
 
             var payments = invoice.GetPayments().Where(p => p.Accounted).ToArray();
@@ -83,7 +82,7 @@ namespace BTCPayServer.HostedServices
                 {
                     if (invoice.Status == InvoiceStatus.New)
                     {
-                        context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1003, InvoiceEvent.PaidInFull));
+                        context.Events.Add(new InvoiceEvent(invoice, 1003, InvoiceEvent.PaidInFull));
                         invoice.Status = InvoiceStatus.Paid;
                         invoice.ExceptionStatus = accounting.Paid > accounting.TotalDue ? InvoiceExceptionStatus.PaidOver : InvoiceExceptionStatus.None;
                         await _InvoiceRepository.UnaffectAddress(invoice.Id);
@@ -92,15 +91,15 @@ namespace BTCPayServer.HostedServices
                     else if (invoice.Status == InvoiceStatus.Expired && invoice.ExceptionStatus != InvoiceExceptionStatus.PaidLate)
                     {
                         invoice.ExceptionStatus = InvoiceExceptionStatus.PaidLate;
-                        context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1009, InvoiceEvent.PaidAfterExpiration));
+                        context.Events.Add(new InvoiceEvent(invoice, 1009, InvoiceEvent.PaidAfterExpiration));
                         context.MarkDirty();
                     }
                 }
 
                 if (accounting.Paid < accounting.MinimumTotalDue && invoice.GetPayments().Count != 0 && invoice.ExceptionStatus != InvoiceExceptionStatus.PaidPartial)
                 {
-                        invoice.ExceptionStatus = InvoiceExceptionStatus.PaidPartial;
-                        context.MarkDirty();
+                    invoice.ExceptionStatus = InvoiceExceptionStatus.PaidPartial;
+                    context.MarkDirty();
                 }
             }
 
@@ -138,15 +137,15 @@ namespace BTCPayServer.HostedServices
                    (confirmedAccounting.Paid < accounting.MinimumTotalDue))
                 {
                     await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1013, InvoiceEvent.FailedToConfirm));
+                    context.Events.Add(new InvoiceEvent(invoice, 1013, InvoiceEvent.FailedToConfirm));
                     invoice.Status = InvoiceStatus.Invalid;
                     context.MarkDirty();
                 }
                 else if (confirmedAccounting.Paid >= accounting.MinimumTotalDue)
                 {
                     await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1005, InvoiceEvent.Confirmed));
                     invoice.Status = InvoiceStatus.Confirmed;
+                    context.Events.Add(new InvoiceEvent(invoice, 1005, InvoiceEvent.Confirmed));
                     context.MarkDirty();
                 }
             }
@@ -156,7 +155,7 @@ namespace BTCPayServer.HostedServices
                 var completedAccounting = paymentMethod.Calculate(p => p.GetCryptoPaymentData().PaymentCompleted(p, network));
                 if (completedAccounting.Paid >= accounting.MinimumTotalDue)
                 {
-                    context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1006, InvoiceEvent.Completed));
+                    context.Events.Add(new InvoiceEvent(invoice, 1006, InvoiceEvent.Completed));
                     invoice.Status = InvoiceStatus.Complete;
                     context.MarkDirty();
                 }
@@ -185,19 +184,6 @@ namespace BTCPayServer.HostedServices
             return result;
         }
 
-        TimeSpan _PollInterval;
-        public TimeSpan PollInterval
-        {
-            get
-            {
-                return _PollInterval;
-            }
-            set
-            {
-                _PollInterval = value;
-            }
-        }
-
         private void Watch(string invoiceId)
         {
             if (invoiceId == null)
@@ -231,25 +217,24 @@ namespace BTCPayServer.HostedServices
         BlockingCollection<string> _WatchRequests = new BlockingCollection<string>(new ConcurrentQueue<string>());
 
         Task _Loop;
-        Task _WaitingInvoices;
         CancellationTokenSource _Cts;
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
             _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
             _Loop = StartLoop(_Cts.Token);
-            _WaitingInvoices = WaitPendingInvoices();
+            _ = WaitPendingInvoices();
 
             leases.Add(_EventAggregator.Subscribe<Events.InvoiceNeedUpdateEvent>(b =>
             {
                 Watch(b.InvoiceId);
             }));
-            leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(b =>
             {
                 if (b.Name == InvoiceEvent.Created)
                 {
                     Watch(b.Invoice.Id);
-                    await Wait(b.Invoice.Id);
+                    _ = Wait(b.Invoice.Id);
                 }
 
                 if (b.Name == InvoiceEvent.ReceivedPayment)
@@ -264,79 +249,76 @@ namespace BTCPayServer.HostedServices
         {
             await Task.WhenAll((await _InvoiceRepository.GetPendingInvoices())
                 .Select(id => Wait(id)).ToArray());
-            _WaitingInvoices = null;
         }
 
         async Task StartLoop(CancellationToken cancellation)
         {
             Logs.PayServer.LogInformation("Start watching invoices");
             await Task.Delay(1).ConfigureAwait(false); // Small hack so that the caller does not block on GetConsumingEnumerable
-            try
+
+            foreach (var invoiceId in _WatchRequests.GetConsumingEnumerable(cancellation))
             {
-                foreach (var invoiceId in _WatchRequests.GetConsumingEnumerable(cancellation))
+                int maxLoop = 5;
+                int loopCount = -1;
+                while (loopCount < maxLoop)
                 {
-                    int maxLoop = 5;
-                    int loopCount = -1;
-                    while (!cancellation.IsCancellationRequested && loopCount < maxLoop)
+                    loopCount++;
+                    try
                     {
-                        loopCount++;
-                        try
+                        cancellation.ThrowIfCancellationRequested();
+                        var invoice = await _InvoiceRepository.GetInvoice(invoiceId, true);
+                        if (invoice == null)
+                            break;
+                        var updateContext = new UpdateInvoiceContext(invoice);
+                        await UpdateInvoice(updateContext);
+                        if (updateContext.Dirty)
                         {
-                            var invoice = await _InvoiceRepository.GetInvoice(invoiceId, true);
-                            if (invoice == null)
-                                break;
-                            var updateContext = new UpdateInvoiceContext(invoice);
-                            await UpdateInvoice(updateContext);
-                            if (updateContext.Dirty)
-                            {
-                                await _InvoiceRepository.UpdateInvoiceStatus(invoice.Id, invoice.GetInvoiceState());
-                                updateContext.Events.Insert(0, new InvoiceDataChangedEvent(invoice));
-                            }
-
-                            foreach (var evt in updateContext.Events)
-                            {
-                                _EventAggregator.Publish(evt, evt.GetType());
-                            }
-
-                            if (invoice.Status == InvoiceStatus.Complete ||
-                               ((invoice.Status == InvoiceStatus.Invalid || invoice.Status == InvoiceStatus.Expired) && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
-                            {
-                                if (await _InvoiceRepository.RemovePendingInvoice(invoice.Id))
-                                    _EventAggregator.Publish(new InvoiceStopWatchedEvent(invoice.Id));
-                                break;
-                            }
-
-                            if (updateContext.Events.Count == 0 || cancellation.IsCancellationRequested)
-                                break;
+                            await _InvoiceRepository.UpdateInvoiceStatus(invoice.Id, invoice.GetInvoiceState());
+                            updateContext.Events.Insert(0, new InvoiceDataChangedEvent(invoice));
                         }
-                        catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
+
+                        foreach (var evt in updateContext.Events)
                         {
+                            _EventAggregator.Publish(evt, evt.GetType());
+                        }
+
+                        if (invoice.Status == InvoiceStatus.Complete ||
+                           ((invoice.Status == InvoiceStatus.Invalid || invoice.Status == InvoiceStatus.Expired) && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
+                        {
+                            if (await _InvoiceRepository.RemovePendingInvoice(invoice.Id))
+                                _EventAggregator.Publish(new InvoiceStopWatchedEvent(invoice.Id));
                             break;
                         }
-                        catch (Exception ex)
-                        {
-                            Logs.PayServer.LogError(ex, "Unhandled error on watching invoice " + invoiceId);
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-                            Task.Delay(10000, cancellation)
-                                .ContinueWith(t => _WatchRequests.Add(invoiceId), TaskScheduler.Default);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+                        if (updateContext.Events.Count == 0)
                             break;
-                        }
+                    }
+                    catch (Exception ex) when (!cancellation.IsCancellationRequested)
+                    {
+                        Logs.PayServer.LogError(ex, "Unhandled error on watching invoice " + invoiceId);
+                        _ = Task.Delay(10000, cancellation)
+                            .ContinueWith(t => Watch(invoiceId), TaskScheduler.Default);
+                        break;
                     }
                 }
             }
-            catch when (cancellation.IsCancellationRequested)
-            {
-            }
-            Logs.PayServer.LogInformation("Stop watching invoices");
         }
 
-        public Task StopAsync(CancellationToken cancellationToken)
+        public async Task StopAsync(CancellationToken cancellationToken)
         {
+            if (_Cts == null)
+                return;
             leases.Dispose();
             _Cts.Cancel();
-            var waitingPendingInvoices = _WaitingInvoices ?? Task.CompletedTask;
-            return Task.WhenAll(waitingPendingInvoices, _Loop);
+            try
+            {
+                await _Loop;
+            }
+            catch { }
+            finally
+            {
+                Logs.PayServer.LogInformation("Stop watching invoices");
+            }
         }
     }
 }

BTCPayServer/HostedServices/MigratorHostedService.cs

@@ -65,6 +65,12 @@ namespace BTCPayServer.HostedServices
                     settings.ConvertNetworkFeeProperty = true;
                     await _Settings.UpdateSetting(settings);
                 }
+                if (!settings.ConvertCrowdfundOldSettings)
+                {
+                    await ConvertCrowdfundOldSettings();
+                    settings.ConvertCrowdfundOldSettings = true;
+                    await _Settings.UpdateSetting(settings);
+                }
             }
             catch (Exception ex)
             {
@@ -73,6 +79,24 @@ namespace BTCPayServer.HostedServices
             }
         }
 
+        private async Task ConvertCrowdfundOldSettings()
+        {
+            using (var ctx = _DBContextFactory.CreateContext())
+            {
+                foreach (var app in ctx.Apps.Where(a => a.AppType == "Crowdfund"))
+                {
+                    var settings = app.GetSettings<Services.Apps.CrowdfundSettings>();
+#pragma warning disable CS0618 // Type or member is obsolete
+                    if (settings.UseAllStoreInvoices)
+#pragma warning restore CS0618 // Type or member is obsolete
+                    {
+                        app.TagAllInvoices = true;
+                    }
+                }
+                await ctx.SaveChangesAsync();
+            }
+        }
+
         private async Task ConvertNetworkFeeProperty()
         {
             using (var ctx = _DBContextFactory.CreateContext())

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -43,7 +43,7 @@ namespace BTCPayServer.HostedServices
 
         public bool IsFullySynched(string cryptoCode, out NBXplorerSummary summary)
         {
-            return _Summaries.TryGetValue(cryptoCode, out summary) && 
+            return _Summaries.TryGetValue(cryptoCode.ToUpperInvariant(), out summary) && 
                    summary.Status != null && 
                    summary.Status.IsFullySynched;
         }

BTCPayServer/HostedServices/RatesHostedService.cs

@@ -1,4 +1,5 @@
 using System;
+using NBitcoin;
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
 using System.Linq;
@@ -47,7 +48,7 @@ namespace BTCPayServer.HostedServices
                 {
                     await Task.WhenAll(_RateProviderFactory.Providers
                                     .Select(p => (Fetcher: p.Value as BackgroundFetcherRateProvider, ExchangeName: p.Key)).Where(p => p.Fetcher != null)
-                                    .Select(p => p.Fetcher.UpdateIfNecessary().ContinueWith(t =>
+                                    .Select(p => p.Fetcher.UpdateIfNecessary(timeout.Token).ContinueWith(t =>
                                     {
                                         if (t.Result.Exception != null)
                                         {
@@ -65,11 +66,10 @@ namespace BTCPayServer.HostedServices
 
         async Task RefreshCoinAverageSupportedExchanges()
         {
-            var tickers = await new CoinAverageRateProvider() { Authenticator = _coinAverageSettings }.GetExchangeTickersAsync();
             var exchanges = new CoinAverageExchanges();
-            foreach (var item in tickers
+            foreach (var item in (await new CoinAverageRateProvider() { Authenticator = _coinAverageSettings }.GetExchangeTickersAsync())
                 .Exchanges
-                .Select(c => new CoinAverageExchange(c.Name, c.DisplayName)))
+                .Select(c => new CoinAverageExchange(c.Name, c.DisplayName, $"https://apiv2.bitcoinaverage.com/exchanges/{c.Name}")))
             {
                 exchanges.Add(item);
             }

BTCPayServer/HostedServices/TorServicesHostedService.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Configuration;
+using BTCPayServer.Services;
+using Microsoft.Extensions.Hosting;
+
+namespace BTCPayServer.HostedServices
+{
+    public class TorServicesHostedService : BaseAsyncService
+    {
+        private readonly BTCPayServerOptions _options;
+        private readonly TorServices _torServices;
+
+        public TorServicesHostedService(BTCPayServerOptions options, TorServices torServices)
+        {
+            _options = options;
+            _torServices = torServices;
+        }
+
+        internal override Task[] InitializeTasks()
+        {
+            // TODO: We should report auto configured services (like bitcoind, lnd or clightning)
+            if (string.IsNullOrEmpty(_options.TorrcFile))
+                return Array.Empty<Task>();
+            return new Task[] { CreateLoopTask(RefreshTorServices) };
+        }
+
+        async Task RefreshTorServices()
+        {
+            await _torServices.Refresh();
+            await Task.Delay(TimeSpan.FromSeconds(120), Cancellation);
+        }
+    }
+}

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -36,17 +36,18 @@ using BTCPayServer.Authentication;
 using Microsoft.Extensions.Caching.Memory;
 using BTCPayServer.Logging;
 using BTCPayServer.HostedServices;
-using Meziantou.AspNetCore.BundleTagHelpers;
 using System.Security.Claims;
-using BTCPayServer.Crowdfund;
-using BTCPayServer.Hubs;
+using BTCPayServer.PaymentRequest;
 using BTCPayServer.Payments.Changelly;
 using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Security;
+using BTCPayServer.Services.PaymentRequests;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 using NBXplorer.DerivationStrategy;
 using NicolasDorier.RateLimits;
 using Npgsql;
+using BTCPayServer.Services.Apps;
+using BundlerMinifier.TagHelpers;
 
 namespace BTCPayServer.Hosting
 {
@@ -61,6 +62,9 @@ namespace BTCPayServer.Hosting
             });
             services.AddHttpClient();
             services.TryAddSingleton<SettingsRepository>();
+            services.TryAddSingleton<TorServices>();
+            services.TryAddSingleton<SocketFactory>();
+            services.TryAddSingleton<LightningClientFactoryService>();
             services.TryAddSingleton<InvoicePaymentNotification>();
             services.TryAddSingleton<BTCPayServerOptions>(o => o.GetRequiredService<IOptions<BTCPayServerOptions>>().Value);
             services.TryAddSingleton<InvoiceRepository>(o =>
@@ -75,8 +79,8 @@ namespace BTCPayServer.Hosting
             services.AddSingleton<BTCPayServerEnvironment>();
             services.TryAddSingleton<TokenRepository>();
             services.TryAddSingleton<EventAggregator>();
+            services.TryAddSingleton<PaymentRequestService>();
             services.TryAddSingleton<CoinAverageSettings>();
-            services.TryAddSingleton<CrowdfundHubStreamer>();
             services.TryAddSingleton<ApplicationDbContextFactory>(o => 
             {
                 var opts = o.GetRequiredService<BTCPayServerOptions>();
@@ -107,12 +111,52 @@ namespace BTCPayServer.Hosting
                 return opts.NetworkProvider;
             });
 
-            services.TryAddSingleton<AppsHelper>();
+            services.TryAddSingleton<AppService>();
+            services.TryAddSingleton<Ganss.XSS.HtmlSanitizer>(o =>
+            {
+
+                var htmlSanitizer = new Ganss.XSS.HtmlSanitizer();
+
+
+                htmlSanitizer.RemovingAtRule += (sender, args) =>
+                {
+                };
+                htmlSanitizer.RemovingTag += (sender, args) =>
+                {
+                    if (args.Tag.TagName.Equals("img", StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        if (!args.Tag.ClassList.Contains("img-fluid"))
+                        {
+                            args.Tag.ClassList.Add("img-fluid");
+                        }
+
+                        args.Cancel = true;
+                    }
+                };
+
+                htmlSanitizer.RemovingAttribute += (sender, args) =>
+                {
+                    if (args.Tag.TagName.Equals("img", StringComparison.InvariantCultureIgnoreCase) &&
+                        args.Attribute.Name.Equals("src", StringComparison.InvariantCultureIgnoreCase) &&
+                        args.Reason == Ganss.XSS.RemoveReason.NotAllowedUrlValue)
+                    {
+                        args.Cancel = true;
+                    }
+                };
+                htmlSanitizer.RemovingStyle += (sender, args) => { args.Cancel = true; };
+                htmlSanitizer.AllowedAttributes.Add("class");
+                htmlSanitizer.AllowedTags.Add("iframe");
+                htmlSanitizer.AllowedTags.Remove("img");
+                htmlSanitizer.AllowedAttributes.Add("webkitallowfullscreen");
+                htmlSanitizer.AllowedAttributes.Add("allowfullscreen");
+                return htmlSanitizer;
+            });
 
             services.TryAddSingleton<LightningConfigurationProvider>();
             services.TryAddSingleton<LanguageService>();
             services.TryAddSingleton<NBXplorerDashboard>();
             services.TryAddSingleton<StoreRepository>();
+            services.TryAddSingleton<PaymentRequestRepository>();
             services.TryAddSingleton<BTCPayWalletProvider>();
             services.TryAddSingleton<CurrencyNameTable>();
             services.TryAddSingleton<IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService<ExplorerClientProvider>())
@@ -146,6 +190,9 @@ namespace BTCPayServer.Hosting
             services.AddSingleton<IHostedService, InvoiceWatcher>();
             services.AddSingleton<IHostedService, RatesHostedService>();
             services.AddSingleton<IHostedService, BackgroundJobSchedulerHostedService>();
+            services.AddSingleton<IHostedService, AppHubStreamer>();
+            services.AddSingleton<IHostedService, TorServicesHostedService>();
+            services.AddSingleton<IHostedService, PaymentRequestStreamer>();
             services.AddSingleton<IBackgroundJobClient, BackgroundJobClient>();
             services.AddTransient<IConfigureOptions<MvcOptions>, BTCPayClaimsFilter>();
 
@@ -164,6 +211,7 @@ namespace BTCPayServer.Hosting
             services.AddTransient<AccessTokenController>();
             services.AddTransient<InvoiceController>();
             services.AddTransient<AppsPublicController>();
+            services.AddTransient<PaymentRequestController>();
             // Add application services.
             services.AddSingleton<EmailSenderFactory>();
             // bundling
@@ -171,7 +219,7 @@ namespace BTCPayServer.Hosting
             services.AddAuthorization(o => Policies.AddBTCPayPolicies(o));
             BitpayAuthentication.AddAuthentication(services);
 
-            services.AddBundles();
+            services.AddSingleton<IBundleProvider, ResourceBundleProvider>();
             services.AddTransient<BundleOptions>(provider =>
             {
                 var opts = provider.GetRequiredService<BTCPayServerOptions>();

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -32,15 +32,24 @@ namespace BTCPayServer.Hosting
 
         public async Task Invoke(HttpContext httpContext)
         {
-            RewriteHostIfNeeded(httpContext);
-
             try
             {
                 var bitpayAuth = GetBitpayAuth(httpContext, out bool isBitpayAuth);
                 var isBitpayAPI = IsBitpayAPI(httpContext, isBitpayAuth);
+                if (isBitpayAPI && httpContext.Request.Method == "OPTIONS")
+                {
+                    httpContext.Response.StatusCode = 200;
+                    httpContext.Response.SetHeader("Access-Control-Allow-Origin", "*");
+                    if (httpContext.Request.Headers.ContainsKey("Access-Control-Request-Headers"))
+                    {
+                        httpContext.Response.SetHeader("Access-Control-Allow-Headers", httpContext.Request.Headers["Access-Control-Request-Headers"].FirstOrDefault());
+                    }
+                    return; // We bypass MVC completely
+                }
                 httpContext.SetIsBitpayAPI(isBitpayAPI);
                 if (isBitpayAPI)
                 {
+                    httpContext.Response.SetHeader("Access-Control-Allow-Origin", "*");
                     httpContext.SetBitpayAuth(bitpayAuth);
                 }
                 await _Next(httpContext);
@@ -79,119 +88,44 @@ namespace BTCPayServer.Hosting
             if (!httpContext.Request.Path.HasValue)
                 return false;
 
+            // In case of anyone can create invoice, the storeId can be set explicitely
+            bitpayAuth |= httpContext.Request.Query.ContainsKey("storeid");
+
             var isJson = (httpContext.Request.ContentType ?? string.Empty).StartsWith("application/json", StringComparison.OrdinalIgnoreCase);
             var path = httpContext.Request.Path.Value;
             var method = httpContext.Request.Method;
+            var isCors = method == "OPTIONS";
 
-            isJson = method == "OPTIONS" ? true : isJson;
             if (
-                bitpayAuth &&
-              (path == "/invoices" || path == "/invoices/") &&
-              (method == "POST" || method == "OPTIONS") &&
-              isJson)
+                (isCors || bitpayAuth) &&
+                (path == "/invoices" || path == "/invoices/") &&
+              (isCors || (method == "POST" && isJson)))
                 return true;
 
             if (
-                bitpayAuth &&
+                (isCors || bitpayAuth) &&
                  (path == "/invoices" || path == "/invoices/") &&
-                 (method == "GET" || method == "OPTIONS"))
+                 (isCors || method == "GET"))
                 return true;
 
             if (
-                path.StartsWith("/invoices/", StringComparison.OrdinalIgnoreCase) &&
-                (method == "GET" || method == "OPTIONS") &&
-                (isJson || httpContext.Request.Query.ContainsKey("token")))
+               path.StartsWith("/invoices/", StringComparison.OrdinalIgnoreCase) &&
+               (isCors || method == "GET") &&
+               (isCors || isJson || httpContext.Request.Query.ContainsKey("token")))
                 return true;
 
             if (path.StartsWith("/rates", StringComparison.OrdinalIgnoreCase) &&
-                (method == "GET" || method == "OPTIONS"))
+                (isCors || method == "GET"))
                 return true;
 
             if (
                 path.Equals("/tokens", StringComparison.Ordinal) &&
-                (method == "GET" || method == "POST" || method == "OPTIONS"))
+                (isCors || method == "GET" || method == "POST"))
                 return true;
 
             return false;
         }
 
-        private void RewriteHostIfNeeded(HttpContext httpContext)
-        {
-            string reverseProxyScheme = null;
-            if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Proto", out StringValues proto))
-            {
-                var scheme = proto.SingleOrDefault();
-                if (scheme != null)
-                {
-                    reverseProxyScheme = scheme;
-                }
-            }
-
-            ushort? reverseProxyPort = null;
-            if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Port", out StringValues port))
-            {
-                var portString = port.SingleOrDefault();
-                if (portString != null && ushort.TryParse(portString, out ushort pp))
-                {
-                    reverseProxyPort = pp;
-                }
-            }
-
-            // Make sure that code executing after this point think that the external url has been hit.
-            if (_Options.ExternalUrl != null)
-            {
-                if (reverseProxyScheme != null && _Options.ExternalUrl.Scheme != reverseProxyScheme)
-                {
-                    if (reverseProxyScheme == "http" && _Options.ExternalUrl.Scheme == "https")
-                        Logs.PayServer.LogWarning($"BTCPay ExternalUrl setting expected to use scheme '{_Options.ExternalUrl.Scheme}' externally, but the reverse proxy uses scheme '{reverseProxyScheme}' (X-Forwarded-Port), forcing ExternalUrl");
-                }
-                httpContext.Request.Scheme = _Options.ExternalUrl.Scheme;
-                if (_Options.ExternalUrl.IsDefaultPort)
-                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host);
-                else
-                {
-                    if (reverseProxyPort != null && _Options.ExternalUrl.Port != reverseProxyPort.Value)
-                    {
-                        Logs.PayServer.LogWarning($"BTCPay ExternalUrl setting expected to use port '{_Options.ExternalUrl.Port}' externally, but the reverse proxy uses port '{reverseProxyPort.Value}'");
-                        httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, reverseProxyPort.Value);
-                    }
-                    else
-                    {
-                        httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, _Options.ExternalUrl.Port);
-                    }
-                }
-            }
-            // NGINX pass X-Forwarded-Proto and X-Forwarded-Port, so let's use that to have better guess of the real domain
-            else
-            {
-                ushort? p = null;
-                if (reverseProxyScheme != null)
-                {
-                    httpContext.Request.Scheme = reverseProxyScheme;
-                    if (reverseProxyScheme == "http")
-                        p = 80;
-                    if (reverseProxyScheme == "https")
-                        p = 443;
-                }
-
-
-                if (reverseProxyPort != null)
-                {
-                    p = reverseProxyPort.Value;
-                }
-
-                if (p.HasValue)
-                {
-                    bool isDefault = httpContext.Request.Scheme == "http" && p.Value == 80;
-                    isDefault |= httpContext.Request.Scheme == "https" && p.Value == 443;
-                    if (isDefault)
-                        httpContext.Request.Host = new HostString(httpContext.Request.Host.Host);
-                    else
-                        httpContext.Request.Host = new HostString(httpContext.Request.Host.Host, p.Value);
-                }
-            }
-        }
-
         private static async Task HandleBitpayHttpException(HttpContext httpContext, BitpayHttpException ex)
         {
             httpContext.Response.StatusCode = ex.StatusCode;

BTCPayServer/Hosting/ResourceBundleProvider.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using BundlerMinifier.TagHelpers;
+using Microsoft.AspNetCore.Hosting;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Hosting
+{
+    public class ResourceBundleProvider : IBundleProvider
+    {
+        BundleProvider _InnerProvider;
+        Lazy<Dictionary<string, Bundle>> _BundlesByName;
+        public ResourceBundleProvider(IHostingEnvironment hosting, BundleOptions options)
+        {
+            if (options.UseBundles)
+            {
+                _BundlesByName = new Lazy<Dictionary<string, Bundle>>(() =>
+                {
+                    using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("BTCPayServer.bundleconfig.json"))
+                    using (var reader = new StreamReader(stream, Encoding.UTF8))
+                    {
+                        var content = reader.ReadToEnd();
+                        return JArray.Parse(content).OfType<JObject>()
+                               .Select(jobj => new Bundle()
+                               {
+                                   Name = jobj.Property("name")?.Value.Value<string>() ?? jobj.Property("outputFileName").Value.Value<string>(),
+                                   OutputFileUrl = Path.Combine(hosting.ContentRootPath, jobj.Property("outputFileName").Value.Value<string>())
+                               }).ToDictionary(o => o.Name, o => o);
+                    }
+                }, true);
+            }
+            else
+            {
+                _InnerProvider = new BundleProvider();
+            }
+        }
+        public Bundle GetBundle(string name)
+        {
+            if (_InnerProvider != null)
+                return _InnerProvider.GetBundle(name);
+            _BundlesByName.Value.TryGetValue(name, out var bundle);
+            return bundle;
+        }
+    }
+}

BTCPayServer/Hosting/Startup.cs

@@ -3,7 +3,6 @@ using System.Reflection;
 using System.Linq;
 using Microsoft.AspNetCore.Builder;
 using System;
-using System.Collections.Generic;
 using System.Text;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -14,9 +13,9 @@ using BTCPayServer.Authentication;
 using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Filters;
 using Microsoft.AspNetCore.Mvc.Infrastructure;
-using BTCPayServer.Services;
 using BTCPayServer.Models;
 using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.HttpOverrides;
 using BTCPayServer.Data;
 using Microsoft.Extensions.Logging;
 using BTCPayServer.Logging;
@@ -34,9 +33,9 @@ using Microsoft.Extensions.Options;
 using Microsoft.AspNetCore.Mvc.Cors.Internal;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 using System.Net;
-using BTCPayServer.Hubs;
-using Meziantou.AspNetCore.BundleTagHelpers;
+using BTCPayServer.PaymentRequest;
 using BTCPayServer.Security;
+using BTCPayServer.Services.Apps;
 
 namespace BTCPayServer.Hosting
 {
@@ -79,7 +78,7 @@ namespace BTCPayServer.Hosting
                 //    StyleSrc = "'self' 'unsafe-inline'",
                 //    ScriptSrc = "'self' 'unsafe-inline'"
                 //});
-            });
+            }).AddControllersAsServices();
             services.TryAddScoped<ContentSecurityPolicies>();
             services.Configure<IdentityOptions>(options =>
             {
@@ -158,13 +157,22 @@ namespace BTCPayServer.Hosting
                 app.UseDeveloperExceptionPage();
             }
 
+            var forwardingOptions = new ForwardedHeadersOptions()
+            {
+                ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
+            };
+            forwardingOptions.KnownNetworks.Clear();
+            forwardingOptions.KnownProxies.Clear();
+            forwardingOptions.ForwardedHeaders = ForwardedHeaders.All;
+            app.UseForwardedHeaders(forwardingOptions);
             app.UseCors();
             app.UsePayServer();
             app.UseStaticFiles();
             app.UseAuthentication();
             app.UseSignalR(route =>
             {
-                route.MapHub<CrowdfundHub>("/apps/crowdfund/hub");
+                AppHub.Register(route);
+                PaymentRequestHub.Register(route);
             });
             app.UseWebSockets();
             app.UseStatusCodePages();

BTCPayServer/JsonConverters/CurrencyPairJsonConverter.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NBitcoin.JsonConverters;
+using BTCPayServer.Rating;
+
+namespace BTCPayServer.JsonConverters
+{
+    public class CurrencyPairJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(CurrencyValue).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            try
+            {
+                return reader.TokenType == JsonToken.Null ? null :
+                       CurrencyPair.TryParse((string)reader.Value, out var result) ? result :
+                       throw new JsonObjectException("Invalid currency pair", reader);
+            }
+            catch (InvalidCastException)
+            {
+                throw new JsonObjectException("Invalid currency pair", reader);
+            }
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value != null)
+                writer.WriteValue(value.ToString());
+        }
+    }
+}

BTCPayServer/Logging/InvoiceLog.cs

@@ -33,5 +33,35 @@ namespace BTCPayServer.Logging
                 return _InvoiceLogs.ToList();
             }
         }
+
+        internal IDisposable Measure(string logs)
+        {
+            return new Mesuring(this, logs);
+        }
+
+        class Mesuring : IDisposable
+        {
+            private readonly InvoiceLogs _logs;
+            private readonly string _msg;
+            private readonly DateTimeOffset _Before;
+            public Mesuring(InvoiceLogs logs, string msg)
+            {
+                _logs = logs;
+                _msg = msg;
+                _Before = DateTimeOffset.UtcNow;
+            }
+            public void Dispose()
+            {
+                var timespan = DateTimeOffset.UtcNow - _Before;
+                if (timespan.TotalSeconds >= 1.0)
+                {
+                    _logs.Write($"{_msg} took {(int)timespan.TotalSeconds} seconds");
+                }
+                else
+                {
+                    _logs.Write($"{_msg} took {(int)timespan.TotalMilliseconds} milliseconds");
+                }
+            }
+        }
     }
 }

BTCPayServer/Migrations/20190121133309_AddPaymentRequests.Designer.cs

@@ -0,0 +1,606 @@
+// <auto-generated />
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190121133309_AddPaymentRequests")]
+    partial class AddPaymentRequests
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.4-rtm-31024");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.Property<string>("Address")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Address");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("AddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(50);
+
+                    b.Property<string>("StoreId")
+                        .HasMaxLength(50);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreId");
+
+                    b.ToTable("ApiKeys");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AppType");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Settings");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Apps");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTimeOffset>("Assigned");
+
+                    b.Property<string>("CryptoCode");
+
+                    b.Property<DateTimeOffset?>("UnAssigned");
+
+                    b.HasKey("InvoiceDataId", "Address");
+
+                    b.ToTable("HistoricalAddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("CustomerEmail");
+
+                    b.Property<string>("ExceptionStatus");
+
+                    b.Property<string>("ItemCode");
+
+                    b.Property<string>("OrderId");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Invoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("UniqueId");
+
+                    b.Property<string>("Message");
+
+                    b.Property<DateTimeOffset>("Timestamp");
+
+                    b.HasKey("InvoiceDataId", "UniqueId");
+
+                    b.ToTable("InvoiceEvents");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<int>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PaymentRequests");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("APIKeys")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Apps")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Invoices")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PairedSINs")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("PendingInvoices")
+                        .HasForeignKey("Id")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PaymentRequests")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer/Migrations/20190121133309_AddPaymentRequests.cs

@@ -0,0 +1,47 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class AddPaymentRequests : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "PaymentRequests",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    StoreDataId = table.Column<string>(nullable: true),
+                    Status = table.Column<int>(nullable: false),
+                    Blob = table.Column<byte[]>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PaymentRequests", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PaymentRequests_Stores_StoreDataId",
+                        column: x => x.StoreDataId,
+                        principalTable: "Stores",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PaymentRequests_Status",
+                table: "PaymentRequests",
+                column: "Status");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PaymentRequests_StoreDataId",
+                table: "PaymentRequests",
+                column: "StoreDataId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "PaymentRequests");
+        }
+    }
+}

BTCPayServer/Migrations/20190219032533_AppsTagging.Designer.cs

@@ -0,0 +1,580 @@
+// <auto-generated />
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190219032533_AppsTagging")]
+    partial class AppsTagging
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.8-servicing-32085");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.Property<string>("Address")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Address");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("AddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(50);
+
+                    b.Property<string>("StoreId")
+                        .HasMaxLength(50);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreId");
+
+                    b.ToTable("ApiKeys");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AppType");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Settings");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<bool>("TagAllInvoices");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Apps");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTimeOffset>("Assigned");
+
+                    b.Property<string>("CryptoCode");
+
+                    b.Property<DateTimeOffset?>("UnAssigned");
+
+                    b.HasKey("InvoiceDataId", "Address");
+
+                    b.ToTable("HistoricalAddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("CustomerEmail");
+
+                    b.Property<string>("ExceptionStatus");
+
+                    b.Property<string>("ItemCode");
+
+                    b.Property<string>("OrderId");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Invoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("UniqueId");
+
+                    b.Property<string>("Message");
+
+                    b.Property<DateTimeOffset>("Timestamp");
+
+                    b.HasKey("InvoiceDataId", "UniqueId");
+
+                    b.ToTable("InvoiceEvents");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("APIKeys")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Apps")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Invoices")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PairedSINs")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("PendingInvoices")
+                        .HasForeignKey("Id")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer/Migrations/20190219032533_AppsTagging.cs

@@ -0,0 +1,23 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class AppsTagging : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "TagAllInvoices",
+                table: "Apps",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "TagAllInvoices",
+                table: "Apps");
+        }
+    }
+}

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -14,7 +14,7 @@ namespace BTCPayServer.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "2.1.0-rtm-30799");
+                .HasAnnotation("ProductVersion", "2.1.8-servicing-32085");
 
             modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
                 {
@@ -63,6 +63,8 @@ namespace BTCPayServer.Migrations
 
                     b.Property<string>("StoreDataId");
 
+                    b.Property<bool>("TagAllInvoices");
+
                     b.HasKey("Id");
 
                     b.HasIndex("StoreDataId");
@@ -326,6 +328,26 @@ namespace BTCPayServer.Migrations
                     b.ToTable("AspNetUsers");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<int>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PaymentRequests");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
                 {
                     b.Property<string>("Id")
@@ -526,6 +548,14 @@ namespace BTCPayServer.Migrations
                         .OnDelete(DeleteBehavior.Cascade);
                 });
 
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PaymentRequests")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")

BTCPayServer/ModelBinders/InvariantDecimalModelBinder.cs

@@ -0,0 +1,99 @@
+// Copied and adjusted from https://github.com/aspnet/Mvc/blob/master/src/Microsoft.AspNetCore.Mvc.Core/ModelBinding/Binders/DecimalModelBinder.cs
+using System;
+using System.Globalization;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace BTCPayServer.ModelBinders
+{
+    /// <summary>
+    /// An <see cref="IModelBinder"/> for <see cref="decimal"/> and <see cref="Nullable{T}"/> where <c>T</c> is
+    /// <see cref="decimal"/>.
+    /// </summary>
+    public class InvariantDecimalModelBinder : IModelBinder
+    {
+        private readonly NumberStyles _supportedStyles;
+
+        public InvariantDecimalModelBinder()
+        {
+            _supportedStyles = NumberStyles.Any;
+        }
+
+        /// <inheritdoc />
+        public Task BindModelAsync(ModelBindingContext bindingContext)
+        {
+            if (bindingContext == null)
+            {
+                throw new ArgumentNullException(nameof(bindingContext));
+            }
+
+            var modelName = bindingContext.ModelName;
+            var valueProviderResult = bindingContext.ValueProvider.GetValue(modelName);
+            if (valueProviderResult == ValueProviderResult.None)
+            {
+                return Task.CompletedTask;
+            }
+
+            var modelState = bindingContext.ModelState;
+            modelState.SetModelValue(modelName, valueProviderResult);
+
+            var metadata = bindingContext.ModelMetadata;
+            var type = metadata.UnderlyingOrModelType;
+            try
+            {
+                var value = valueProviderResult.FirstValue;
+                var culture = CultureInfo.InvariantCulture;
+
+                object model;
+                if (string.IsNullOrWhiteSpace(value))
+                {
+                    // Parse() method trims the value (with common NumberStyles) then throws if the result is empty.
+                    model = null;
+                }
+                else if (type == typeof(decimal))
+                {
+                    model = decimal.Parse(value, _supportedStyles, culture);
+                }
+                else
+                {
+                    // unreachable
+                    throw new NotSupportedException();
+                }
+
+                // When converting value, a null model may indicate a failed conversion for an otherwise required
+                // model (can't set a ValueType to null). This detects if a null model value is acceptable given the
+                // current bindingContext. If not, an error is logged.
+                if (model == null && !metadata.IsReferenceOrNullableType)
+                {
+                    modelState.TryAddModelError(
+                        modelName,
+                        metadata.ModelBindingMessageProvider.ValueMustNotBeNullAccessor(
+                            valueProviderResult.ToString()));
+                }
+                else
+                {
+                    bindingContext.Result = ModelBindingResult.Success(model);
+                }
+            }
+            catch (Exception exception)
+            {
+                var isFormatException = exception is FormatException;
+                if (!isFormatException && exception.InnerException != null)
+                {
+                    // Unlike TypeConverters, floating point types do not seem to wrap FormatExceptions. Preserve
+                    // this code in case a cursory review of the CoreFx code missed something.
+                    exception = ExceptionDispatchInfo.Capture(exception.InnerException).SourceException;
+                }
+
+                modelState.TryAddModelError(modelName, exception, metadata);
+
+                // Conversion failed.
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+}

BTCPayServer/Models/AppViewModels/UpdateCrowdfundViewModel.cs

@@ -2,6 +2,8 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Validation;
 
 namespace BTCPayServer.Models.AppViewModels
 {
@@ -15,8 +17,13 @@ namespace BTCPayServer.Models.AppViewModels
         
         [Display(Name = "Featured Image")]
         public string MainImageUrl { get; set; }
-
+        
+        [Display(Name = "Callback Notification Url")] 
+        [Uri]
         public string NotificationUrl { get; set; }
+        [Display(Name = "Invoice Email Notification")]
+        [EmailAddress]
+        public string NotificationEmail { get; set; }
 
         [Required]
         [Display(Name = "Allow crowdfund to be publicly visible (still visible to you)")]
@@ -41,10 +48,11 @@ namespace BTCPayServer.Models.AppViewModels
 
         [Required]
         [MaxLength(5)]
-        [Display(Name = "The primary currency used for targets and stats. (e.g. BTC, LTC, USD, etc.)")]
+        [Display(Name = "Primary currency used for targets and stats. (e.g. BTC, LTC, USD, etc.)")]
         public string TargetCurrency { get; set; } = "BTC";
 
         [Display(Name = "Set a Target amount ")]
+        [Range(0, double.PositiveInfinity)]
         public decimal? TargetAmount { get; set; }
 
 
@@ -68,24 +76,21 @@ namespace BTCPayServer.Models.AppViewModels
         [Display(Name = "Custom CSS Code")]
         public string EmbeddedCSS { get; set; }
 
-        [Display(Name = "Base the contributed goal amount on the invoice amount and not actual payments")]
-        public bool UseInvoiceAmount { get; set; }       
         [Display(Name = "Count all invoices created on the store as part of the crowdfunding goal")]
         public bool UseAllStoreInvoices { get; set; } 
 
         public string AppId { get; set; }
+        public string SearchTerm { get; set; }
+
         [Display(Name = "Sort contribution perks by popularity")]
         public bool SortPerksByPopularity { get; set; }
         [Display(Name = "Display contribution ranking")]
         public bool DisplayPerksRanking { get; set; }
-    }
 
-    public enum CrowdfundResetEvery
-    {
-        Never,
-        Hour,
-        Day,
-        Month,
-        Year
+
+        [Display(Name = "Sounds to play when a payment is made. One sound per line")]
+        public string Sounds{ get; set; }
+        [Display(Name = "Colors to rotate between with animation when a payment is made. First color is the default background. One color per line. Can be any valid css color value.")]
+        public string AnimationColors{ get; set; }
     }
 }

BTCPayServer/Models/AppViewModels/UpdatePointOfSaleViewModel.cs

@@ -1,4 +1,7 @@
-using System.ComponentModel.DataAnnotations;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Validation;
+using Microsoft.AspNetCore.Mvc.Rendering;
 
 namespace BTCPayServer.Models.AppViewModels
 {
@@ -10,17 +13,27 @@ namespace BTCPayServer.Models.AppViewModels
         [Required]
         [MaxLength(5)]
         public string Currency { get; set; }
-        [MaxLength(5000)]
         public string Template { get; set; }
 
         [Display(Name = "Enable shopping cart")]
         public bool EnableShoppingCart { get; set; }
         [Display(Name = "User can input custom amount")]
         public bool ShowCustomAmount { get; set; }
+        [Display(Name = "User can input discount in %")]
+        public bool ShowDiscount { get; set; }
+        [Display(Name = "Enable tips")]
+        public bool EnableTips { get; set; }
         public string Example1 { get; internal set; }
         public string Example2 { get; internal set; }
         public string ExampleCallback { get; internal set; }
         public string InvoiceUrl { get; internal set; }
+        
+        [Display(Name = "Callback Notification Url")] 
+        [Uri]
+        public string NotificationUrl { get; set; }
+        [Display(Name = "Invoice Email Notification")]
+        [EmailAddress]
+        public string NotificationEmail { get; set; }
 
         [Required]
         [MaxLength(30)]
@@ -43,5 +56,28 @@ namespace BTCPayServer.Models.AppViewModels
         public string CustomCSSLink { get; set; }
 
         public string Id { get; set; }
+
+        [Display(Name = "Redirect invoice to redirect url automatically after paid")]
+        public string RedirectAutomatically { get; set; } = string.Empty;
+
+        public SelectList RedirectAutomaticallySelectList =>
+            new SelectList(new List< SelectListItem>()
+            {
+                new SelectListItem()
+                {
+                    Text = "Yes",
+                    Value = "true"
+                },
+                new SelectListItem()
+                {
+                    Text = "No",
+                    Value = "false"
+                },
+                new SelectListItem()
+                {
+                    Text = "Use Store Settings",
+                    Value = ""
+                }
+            }, nameof(SelectListItem.Value), nameof(SelectListItem.Text), RedirectAutomatically);
     }
 }

BTCPayServer/Models/AppViewModels/ViewCrowdfundViewModel.cs

@@ -1,13 +1,16 @@
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Threading.Tasks;
+using BTCPayServer.Payments;
 using BTCPayServer.Services.Rates;
 
 namespace BTCPayServer.Models.AppViewModels
 {
     public class ViewCrowdfundViewModel
     {
+        public string HubPath { get; set; }
         public string StatusMessage{ get; set; }
         public string StoreId { get; set; }
         public string AppId { get; set; }
@@ -30,8 +33,10 @@ namespace BTCPayServer.Models.AppViewModels
         public bool SoundsEnabled { get; set; }
         public string DisqusShortname { get; set; }
         public bool AnimationsEnabled { get; set; }
+        public string[] AnimationColors { get; set; }
+        public string[] Sounds { get; set; }
         public int ResetEveryAmount { get; set; }
-        public string ResetEvery { get; set; }
+        public bool NeverReset { get; set; }
 
         public Dictionary<string, int> PerkCount { get; set; }
 
@@ -50,11 +55,26 @@ namespace BTCPayServer.Models.AppViewModels
             public DateTime? LastResetDate { get; set; }
             public DateTime? NextResetDate { get; set; }
         }
+        public class Contribution
+        {
+            public PaymentMethodId PaymentMehtodId { get; set; }
+            public decimal Value { get; set; }
+            public decimal CurrencyValue { get; set; }
+        }
+        public class Contributions : Dictionary<PaymentMethodId, Contribution>
+        {
+            public Contributions(IEnumerable<KeyValuePair<PaymentMethodId, Contribution>> collection) : base(collection)
+            {
+                TotalCurrency = Values.Select(v => v.CurrencyValue).Sum();
+            }
+            public decimal TotalCurrency { get; }
+        }
 
         public bool Started => !StartDate.HasValue || DateTime.Now.ToUniversalTime() > StartDate;
 
         public bool Ended => !EndDate.HasValue || DateTime.Now.ToUniversalTime() > EndDate;
         public bool DisplayPerksRanking { get; set; }
+        public bool Enabled { get; set; }
     }
 
     public class ContributeToCrowdfund

BTCPayServer/Models/AppViewModels/ViewPointOfSaleViewModel.cs

@@ -36,6 +36,8 @@ namespace BTCPayServer.Models.AppViewModels
 
         public bool EnableShoppingCart { get; set; }
         public bool ShowCustomAmount { get; set; }
+        public bool ShowDiscount { get; set; }
+        public bool EnableTips { get; set; }
         public string Step { get; set; }
         public string Title { get; set; }
         public Item[] Items { get; set; }

BTCPayServer/Models/ConfirmModel.cs

@@ -7,6 +7,15 @@ namespace BTCPayServer.Models
 {
     public class ConfirmModel
     {
+        public ConfirmModel() { }
+
+        public ConfirmModel(string title, string desc, string action = null)
+        {
+            Title = title;
+            Description = desc;
+            Action = action;
+        }
+
         public string Title
         {
             get; set;

BTCPayServer/Models/CreateInvoiceRequest.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBitcoin.JsonConverters;
+using NBitpayClient;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Models
+{
+    public class CreateInvoiceRequest
+    {
+        [JsonProperty(PropertyName = "buyer")]
+        public Buyer Buyer { get; set; }
+        [JsonProperty(PropertyName = "buyerEmail", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerEmail { get; set; }
+        [JsonProperty(PropertyName = "buyerCountry", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerCountry { get; set; }
+        [JsonProperty(PropertyName = "buyerZip", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerZip { get; set; }
+        [JsonProperty(PropertyName = "buyerState", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerState { get; set; }
+        [JsonProperty(PropertyName = "buyerCity", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerCity { get; set; }
+        [JsonProperty(PropertyName = "buyerAddress2", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerAddress2 { get; set; }
+        [JsonProperty(PropertyName = "buyerAddress1", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerAddress1 { get; set; }
+        [JsonProperty(PropertyName = "buyerName", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerName { get; set; }
+        [JsonProperty(PropertyName = "physical", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool Physical { get; set; }
+        [JsonProperty(PropertyName = "redirectURL", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string RedirectURL { get; set; }
+        [JsonProperty(PropertyName = "notificationURL", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string NotificationURL { get; set; }
+        [JsonProperty(PropertyName = "extendedNotifications", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool ExtendedNotifications { get; set; }
+        [JsonProperty(PropertyName = "fullNotifications", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool FullNotifications { get; set; }
+        [JsonProperty(PropertyName = "transactionSpeed", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string TransactionSpeed { get; set; }
+        [JsonProperty(PropertyName = "buyerPhone", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string BuyerPhone { get; set; }
+        [JsonProperty(PropertyName = "posData", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string PosData { get; set; }
+        [JsonProperty(PropertyName = "itemCode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string ItemCode { get; set; }
+        [JsonProperty(PropertyName = "itemDesc", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string ItemDesc { get; set; }
+        [JsonProperty(PropertyName = "orderId", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string OrderId { get; set; }
+        [JsonProperty(PropertyName = "currency", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string Currency { get; set; }
+        [JsonProperty(PropertyName = "price", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public decimal Price { get; set; }
+        [JsonProperty(PropertyName = "notificationEmail", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string NotificationEmail { get; set; }
+        [JsonConverter(typeof(DateTimeJsonConverter))]
+        [JsonProperty(PropertyName = "expirationTime", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public DateTimeOffset? ExpirationTime { get; set; }
+        [JsonProperty(PropertyName = "status", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string Status { get; set; }
+        [JsonProperty(PropertyName = "minerFees", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public Dictionary<string, MinerFeeInfo> MinerFees { get; set; }
+        [JsonProperty(PropertyName = "supportedTransactionCurrencies", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public Dictionary<string, InvoiceSupportedTransactionCurrency> SupportedTransactionCurrencies { get; set; }
+        [JsonProperty(PropertyName = "exchangeRates", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public Dictionary<string, Dictionary<string, decimal>> ExchangeRates { get; set; }
+        [JsonProperty(PropertyName = "refundable", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool Refundable { get; set; }
+        [JsonProperty(PropertyName = "taxIncluded", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public decimal? TaxIncluded { get; set; }
+        [JsonProperty(PropertyName = "nonce", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public long Nonce { get; set; }
+        [JsonProperty(PropertyName = "guid", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string Guid { get; set; }
+        [JsonProperty(PropertyName = "token", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string Token { get; set; }
+
+        [JsonProperty(PropertyName = "redirectAutomatically", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool? RedirectAutomatically { get; set; }
+    }
+}

BTCPayServer/Models/GetTokensResponse.cs

@@ -39,7 +39,7 @@ namespace BTCPayServer.Models
             {
                 JObject item = new JObject();
                 jarray.Add(item);
-                JProperty jProp = new JProperty(token.Facade);
+                JProperty jProp = new JProperty("merchant");
                 item.Add(jProp);
                 jProp.Value = token.Value;
             }

BTCPayServer/Models/InvoicingModels/PaymentModel.cs

@@ -20,6 +20,7 @@ namespace BTCPayServer.Models.InvoicingModels
         public string CustomCSSLink { get; set; }
         public string CustomLogoLink { get; set; }
         public string DefaultLang { get; set; }
+        public bool LightningAmountInSatoshi { get; set; }
         public List<AvailableCrypto> AvailableCryptos { get; set; } = new List<AvailableCrypto>();
         public bool IsModal { get; set; }
         public bool IsLightning { get; set; }
@@ -64,5 +65,8 @@ namespace BTCPayServer.Models.InvoicingModels
         public bool CoinSwitchEnabled { get; set; }
         public string CoinSwitchMode { get; set; }
         public string CoinSwitchMerchantId { get; set; }
+        public string RootPath { get; set; }
+        public decimal CoinSwitchAmountMarkupPercentage { get; set; }
+        public bool RedirectAutomatically { get; set; }
     }
 }

BTCPayServer/Models/PaymentRequestViewModels/ListPaymentRequestsViewModel.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Services.PaymentRequests;
+using BTCPayServer.Services.Rates;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.PaymentRequestViewModels
+{
+    public class ListPaymentRequestsViewModel
+    {
+        public int Skip { get; set; }
+        public int Count { get; set; }
+
+        public List<ViewPaymentRequestViewModel> Items { get; set; }
+
+        public string StatusMessage { get; set; }
+        public int Total { get; set; }
+    }
+
+    public class UpdatePaymentRequestViewModel
+    {
+        public UpdatePaymentRequestViewModel()
+        {
+        }
+
+        public UpdatePaymentRequestViewModel(PaymentRequestData data)
+        {
+            if (data == null)
+            {
+                return;
+            }
+
+            Id = data.Id;
+            StoreId = data.StoreDataId;
+
+            var blob = data.GetBlob();
+            Title = blob.Title;
+            Amount = blob.Amount;
+            Currency = blob.Currency;
+            Description = blob.Description;
+            ExpiryDate = blob.ExpiryDate;
+            Email = blob.Email;
+            CustomCSSLink = blob.CustomCSSLink;
+            EmbeddedCSS = blob.EmbeddedCSS;
+            AllowCustomPaymentAmounts = blob.AllowCustomPaymentAmounts;
+        }
+
+        public string Id { get; set; }
+        [Required] public string StoreId { get; set; }
+        [Required][Range(0, double.PositiveInfinity)]public decimal Amount { get; set; }
+
+        [Display(Name = "The currency used for payment request. (e.g. BTC, LTC, USD, etc.)")]
+        public string Currency { get; set; }
+
+        [Display(Name = "Expiration Date")]
+        public DateTime? ExpiryDate { get; set; }
+        [Required] public string Title { get; set; }
+        public string Description { get; set; }
+        public string StatusMessage { get; set; }
+
+        public SelectList Stores { get; set; }
+        [EmailAddress]
+        public string Email { get; set; }
+        
+        [MaxLength(500)]
+        [Display(Name = "Custom bootstrap CSS file")]
+        public string CustomCSSLink { get; set; }
+
+        [Display(Name = "Custom CSS Code")]
+        public string EmbeddedCSS { get; set; }        
+        [Display(Name = "Allow payee to create invoices in their own denomination")]
+        public bool AllowCustomPaymentAmounts { get; set; }
+    }
+
+    public class ViewPaymentRequestViewModel
+    {
+        public ViewPaymentRequestViewModel(PaymentRequestData data)
+        {
+            Id = data.Id;
+            var blob = data.GetBlob();
+            Title = blob.Title;
+            Amount = blob.Amount;
+            Currency = blob.Currency;
+            Description = blob.Description;
+            ExpiryDate = blob.ExpiryDate;
+            Email = blob.Email;
+            EmbeddedCSS = blob.EmbeddedCSS;
+            CustomCSSLink = blob.CustomCSSLink;
+            AllowCustomPaymentAmounts = blob.AllowCustomPaymentAmounts;
+            switch (data.Status)
+            {
+                case PaymentRequestData.PaymentRequestStatus.Pending:
+                    Status = ExpiryDate.HasValue ? $"Expires on {ExpiryDate.Value:g}" : "Pending";
+                    IsPending = true;
+                    break;
+                case PaymentRequestData.PaymentRequestStatus.Completed:
+                    Status = "Settled";
+                    break;
+                case PaymentRequestData.PaymentRequestStatus.Expired:
+                    Status = "Expired";
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public bool AllowCustomPaymentAmounts { get; set; }
+
+
+        public string Email { get; set; }
+
+        public string Status { get; set; }
+        public bool IsPending { get; set; }
+
+        public decimal AmountCollected { get; set; }
+        public decimal AmountDue { get; set; }
+        public string AmountDueFormatted { get; set; }
+        public decimal Amount { get; set; }
+        public string Id { get; set; }
+        public string Currency { get; set; }
+
+        public DateTime? ExpiryDate { get; set; }
+
+        public string Title { get; set; }
+        public string Description { get; set; }
+        
+        public string EmbeddedCSS { get; set; }
+        public string CustomCSSLink { get; set; }
+
+        public List<PaymentRequestInvoice> Invoices { get; set; } = new List<PaymentRequestInvoice>();
+        public DateTime LastUpdated { get; set; }
+        public CurrencyData CurrencyData { get; set; }
+        public string AmountCollectedFormatted { get; set; }
+        public string AmountFormatted { get; set; }
+        public bool AnyPendingInvoice { get; set; }
+        public string HubPath { get; set; }
+
+        public class PaymentRequestInvoice
+        {
+            public string Id { get; set; }
+            public DateTime ExpiryDate { get; set; }
+            public decimal Amount { get; set; }
+            public string AmountFormatted { get; set; }
+            public string Status { get; set; }
+
+            public List<PaymentRequestInvoicePayment> Payments { get; set; }
+            public string Currency { get; set; }
+        }
+
+        public class PaymentRequestInvoicePayment
+        {
+            public string PaymentMethod { get; set; }
+            public decimal Amount { get; set; }
+            public string Link { get; set; }
+            public string Id { get; set; }
+        }
+    }
+}

BTCPayServer/Models/ServerViewModels/EmailsViewModel.cs

@@ -18,8 +18,9 @@ namespace BTCPayServer.Models.ServerViewModels
         {
             get; set;
         }
-        
+
         [EmailAddress]
+        [Display(Name = "Test Email")]
         public string TestEmail
         {
             get; set;

BTCPayServer/Models/ServerViewModels/LightningWalletServices.cs

@@ -5,9 +5,10 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Models.ServerViewModels
 {
-    public class SparkServicesViewModel
+    public class LightningWalletServices
     {
-        public string SparkLink { get; set; }
+        public string ServiceLink { get; set; }
         public bool ShowQR { get; set; }
+        public string WalletName { get; internal set; }
     }
 }

BTCPayServer/Models/ServerViewModels/ServicesViewModel.cs

@@ -2,27 +2,23 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Configuration.External;
+using BTCPayServer.Configuration;
+using BTCPayServer.Services;
 
 namespace BTCPayServer.Models.ServerViewModels
 {
     public class ServicesViewModel
     {
-        public class LNDServiceViewModel
-        {
-            public string Crypto { get; set; }
-            public string Type { get; set; }
-            public int Index { get; set; }
-            public string Action { get; internal set; }
-        }
 
-        public class ExternalService
+        public class OtherExternalService
         {
             public string Name { get; set; }
             public string Link { get; set; }
         }
 
-        public List<LNDServiceViewModel> LNDServices { get; set; } = new List<LNDServiceViewModel>();
         public List<ExternalService> ExternalServices { get; set; } = new List<ExternalService>();
+        public List<OtherExternalService> OtherExternalServices { get; set; } = new List<OtherExternalService>();
+        public List<OtherExternalService> TorHttpServices { get; set; } = new List<OtherExternalService>();
+        public List<OtherExternalService> TorOtherServices { get; set; } = new List<OtherExternalService>();
     }
 }

BTCPayServer/Models/StoreViewModels/CheckoutExperienceViewModel.cs

@@ -21,23 +21,10 @@ namespace BTCPayServer.Models.StoreViewModels
         public SelectList CryptoCurrencies { get; set; }
         public SelectList Languages { get; set; }
 
-        [Display(Name = "Default the default payment method on checkout")]
+        [Display(Name = "Default payment method on checkout")]
         public string DefaultPaymentMethod { get; set; }
         [Display(Name = "Default language on checkout")]
         public string DefaultLang { get; set; }
-        [Display(Name = "Do not propose lightning payment if value of the invoice is above...")]
-        [MaxLength(20)]
-        public string LightningMaxValue { get; set; }
-
-        [Display(Name = "Requires a refund email")]
-        public bool RequiresRefundEmail
-        {
-            get; set;
-        }
-
-        [Display(Name = "Do not propose on chain payment if the value of the invoice is below...")]
-        [MaxLength(20)]
-        public string OnChainMinValue { get; set; }
 
         [Display(Name = "Link to a custom CSS stylesheet")]
         [Uri]
@@ -49,9 +36,26 @@ namespace BTCPayServer.Models.StoreViewModels
         [Display(Name = "Custom HTML title to display on Checkout page")]
         public string HtmlTitle { get; set; }
 
+        [Display(Name = "Requires a refund email")]
+        public bool RequiresRefundEmail { get; set; }
+
+        [Display(Name = "Do not propose on chain payment if the value of the invoice is below...")]
+        [MaxLength(20)]
+        public string OnChainMinValue { get; set; }
+
+        [Display(Name = "Do not propose lightning payment if value of the invoice is above...")]
+        [MaxLength(20)]
+        public string LightningMaxValue { get; set; }
+
+        [Display(Name = "Display lightning payment amounts in Satoshis")]
+        public bool LightningAmountInSatoshi { get; set; }
+        
+        [Display(Name = "Redirect invoice to redirect url automatically after paid")]
+        public bool  RedirectAutomatically { get; set; }
+
         public void SetLanguages(LanguageService langService, string defaultLang)
         {
-            defaultLang = langService.GetLanguages().Any(language => language.Code == defaultLang)? defaultLang : "en";
+            defaultLang = langService.GetLanguages().Any(language => language.Code == defaultLang) ? defaultLang : "en";
             var choices = langService.GetLanguages().Select(o => new Format() { Name = o.DisplayName, Value = o.Code }).ToArray();
             var chosen = choices.FirstOrDefault(f => f.Value == defaultLang) ?? choices.FirstOrDefault();
             Languages = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);

BTCPayServer/Models/StoreViewModels/PairingModel.cs

@@ -27,10 +27,6 @@ namespace BTCPayServer.Models.StoreViewModels
         {
             get; set;
         }
-        public string Facade
-        {
-            get; set;
-        }
         public string SIN
         {
             get; set;

BTCPayServer/Models/StoreViewModels/PayButtonViewModel.cs

@@ -1,13 +1,13 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using System.Linq;
-using System.Threading.Tasks;
+using BTCPayServer.ModelBinders;
+using Microsoft.AspNetCore.Mvc;
 
 namespace BTCPayServer.Models.StoreViewModels
 {
     public class PayButtonViewModel
     {
+        [ModelBinder(BinderType = typeof(InvariantDecimalModelBinder))]
         public decimal Price { get; set; }
         public string InvoiceId { get; set; }
         [Required]
@@ -15,6 +15,13 @@ namespace BTCPayServer.Models.StoreViewModels
         public string CheckoutDesc { get; set; }
         public string OrderId { get; set; }
         public int ButtonSize { get; set; }
+        public int ButtonType { get; set; }
+
+        // Slider properties (ButtonType = 2)
+        public decimal Min { get; set; }
+        public decimal Max { get; set; }
+        public decimal Step { get; set; }
+
         [Url]
         public string ServerIpn { get; set; }
         [Url]

BTCPayServer/Models/StoreViewModels/RatesViewModel.cs

@@ -21,14 +21,16 @@ namespace BTCPayServer.Models.StoreViewModels
         {
             public string Name { get; set; }
             public string Value { get; set; }
+            public string Url { get; set; }
         }
         public void SetExchangeRates(CoinAverageExchange[] supportedList, string preferredExchange)
         {
             var defaultStore = preferredExchange ?? CoinAverageRateProvider.CoinAverageName;
-            var choices = supportedList.Select(o => new Format() { Name = o.Display, Value = o.Name }).ToArray();
+            var choices = supportedList.Select(o => new Format() { Name = o.Display, Value = o.Name, Url = o.Url }).ToArray();
             var chosen = choices.FirstOrDefault(f => f.Value == defaultStore) ?? choices.FirstOrDefault();
             Exchanges = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
             PreferredExchange = chosen.Value;
+            RateSource = chosen.Url;
         }
 
         public List<TestResultViewModel> TestRateRules { get; set; }
@@ -42,6 +44,8 @@ namespace BTCPayServer.Models.StoreViewModels
         public string Script { get; set; }
         public string DefaultScript { get; set; }
         public string ScriptTest { get; set; }
+        public string DefaultCurrencyPairs { get; set; }
+        public string StoreId { get; set; }
         public CoinAverageExchange[] AvailableExchanges { get; set; }
 
         [Display(Name = "Add a spread on exchange rate of ... %")]
@@ -57,10 +61,8 @@ namespace BTCPayServer.Models.StoreViewModels
 
         public string RateSource
         {
-            get
-            {
-                return PreferredExchange == CoinAverageRateProvider.CoinAverageName ? "https://apiv2.bitcoinaverage.com/indices/global/ticker/short" : $"https://apiv2.bitcoinaverage.com/exchanges/{PreferredExchange}";
-            }
+            get;
+            set;
         }
     }
 }

BTCPayServer/Models/StoreViewModels/TokensViewModel.cs

@@ -21,12 +21,6 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         }
 
-        [Required]
-        public string Facade
-        {
-            get; set;
-        }
-
         [Required]
         public string StoreId
         {
@@ -52,10 +46,6 @@ namespace BTCPayServer.Models.StoreViewModels
         {
             get; set;
         }
-        public string Facade
-        {
-            get; set;
-        }
     }
     public class TokensViewModel
     {

BTCPayServer/Models/StoreViewModels/UpdateCoinSwitchSettingsViewModel.cs

@@ -12,6 +12,12 @@ namespace BTCPayServer.Models.StoreViewModels
 
         [Display(Name = "Integration Mode")]
         public string Mode { get; set; } = "inline";
+        
+        [Required]
+        [Range(0, 100)]
+        [Display(Name =
+            "Percentage to multiply amount requested at Coinswitch to avoid underpaid situations due to Coinswitch not guaranteeing rates. ")]
+        public decimal AmountMarkupPercentage { get; set; } = new decimal(2);
 
         public List<SelectListItem> Modes { get; } = new List<SelectListItem>
         {

BTCPayServer/Models/TokenRequest.cs

@@ -20,11 +20,6 @@ namespace BTCPayServer.Models
         {
             get; set;
         }
-        [JsonProperty(PropertyName = "facade")]
-        public string Facade
-        {
-            get; set;
-        }
         [JsonProperty(PropertyName = "count")]
         public int Count
         {

BTCPayServer/PaymentRequest/PaymentRequestHub.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Linq;
+using Microsoft.Extensions.Logging;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Events;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Logging;
+using BTCPayServer.Payments;
+using BTCPayServer.Services.PaymentRequests;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.SignalR;
+using BTCPayServer.Services.Apps;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.PaymentRequest
+{
+    public class PaymentRequestHub : Hub
+    {
+        private readonly PaymentRequestController _PaymentRequestController;
+        public const string InvoiceCreated = "InvoiceCreated";
+        public const string PaymentReceived = "PaymentReceived";
+        public const string InfoUpdated = "InfoUpdated";
+        public const string InvoiceError = "InvoiceError";
+
+        public PaymentRequestHub(PaymentRequestController paymentRequestController)
+        {
+            _PaymentRequestController = paymentRequestController;
+        }
+
+        public async Task ListenToPaymentRequest(string paymentRequestId)
+        {
+            if (Context.Items.ContainsKey("pr-id"))
+            {
+                await Groups.RemoveFromGroupAsync(Context.ConnectionId, Context.Items["pr-id"].ToString());
+                Context.Items.Remove("pr-id");
+            }
+
+            Context.Items.Add("pr-id", paymentRequestId);
+            await Groups.AddToGroupAsync(Context.ConnectionId, paymentRequestId);
+        }
+
+
+        public async Task Pay(decimal? amount = null)
+        {
+            _PaymentRequestController.ControllerContext.HttpContext = Context.GetHttpContext();
+            var result =
+                await _PaymentRequestController.PayPaymentRequest(Context.Items["pr-id"].ToString(), false, amount);
+            switch (result)
+            {
+                case OkObjectResult okObjectResult:
+                    await Clients.Caller.SendCoreAsync(InvoiceCreated, new[] {okObjectResult.Value.ToString()});
+                    break;
+                case ObjectResult objectResult:
+                    await Clients.Caller.SendCoreAsync(InvoiceError, new[] {objectResult.Value});
+                    break;
+                default:
+                    await Clients.Caller.SendCoreAsync(InvoiceError, System.Array.Empty<object>());
+                    break;
+            }
+        }
+
+        public static string GetHubPath(HttpRequest request)
+        {
+            return request.GetRelativePathOrAbsolute("/payment-requests/hub");
+        }
+        public static void Register(HubRouteBuilder route)
+        {
+            route.MapHub<PaymentRequestHub>("/payment-requests/hub");
+        }
+    }
+
+    public class PaymentRequestStreamer : EventHostedServiceBase
+    {
+        private readonly IHubContext<PaymentRequestHub> _HubContext;
+        private readonly PaymentRequestRepository _PaymentRequestRepository;
+        private readonly PaymentRequestService _PaymentRequestService;
+
+
+        public PaymentRequestStreamer(EventAggregator eventAggregator,
+            IHubContext<PaymentRequestHub> hubContext,
+            PaymentRequestRepository paymentRequestRepository,
+            PaymentRequestService paymentRequestService) : base(eventAggregator)
+        {
+            _HubContext = hubContext;
+            _PaymentRequestRepository = paymentRequestRepository;
+            _PaymentRequestService = paymentRequestService;
+        }
+
+        public override async Task StartAsync(CancellationToken cancellationToken)
+        {
+            await base.StartAsync(cancellationToken);
+            _CheckingPendingPayments = CheckingPendingPayments(cancellationToken)
+                .ContinueWith(_ => _CheckingPendingPayments = null, TaskScheduler.Default);
+        }
+
+        private async Task CheckingPendingPayments(CancellationToken cancellationToken)
+        {
+            Logs.PayServer.LogInformation("Starting payment request expiration watcher");
+            var (total, items) = await _PaymentRequestRepository.FindPaymentRequests(new PaymentRequestQuery()
+            {
+                Status = new[] {PaymentRequestData.PaymentRequestStatus.Pending}
+            }, cancellationToken);
+
+            Logs.PayServer.LogInformation($"{total} pending payment requests being checked since last run");
+            await Task.WhenAll(items.Select(i => _PaymentRequestService.UpdatePaymentRequestStateIfNeeded(i))
+                .ToArray());
+        }
+
+        Task _CheckingPendingPayments;
+
+        public override async Task StopAsync(CancellationToken cancellationToken)
+        {
+            await base.StopAsync(cancellationToken);
+            await (_CheckingPendingPayments ?? Task.CompletedTask);
+        }
+
+        protected override void SubscibeToEvents()
+        {
+            Subscribe<InvoiceEvent>();
+            Subscribe<PaymentRequestUpdated>();
+        }
+
+        protected override async Task ProcessEvent(object evt, CancellationToken cancellationToken)
+        {
+            if (evt is InvoiceEvent invoiceEvent)
+            {
+                foreach (var paymentId in PaymentRequestRepository.GetPaymentIdsFromInternalTags(invoiceEvent.Invoice))
+                {
+                    if (invoiceEvent.Name == InvoiceEvent.ReceivedPayment)
+                    {
+                        await _PaymentRequestService.UpdatePaymentRequestStateIfNeeded(paymentId);
+                        var data = invoiceEvent.Payment.GetCryptoPaymentData();
+                        await _HubContext.Clients.Group(paymentId).SendCoreAsync(PaymentRequestHub.PaymentReceived,
+                            new object[]
+                            {
+                            data.GetValue(),
+                            invoiceEvent.Payment.GetCryptoCode(),
+                            Enum.GetName(typeof(PaymentTypes),
+                                invoiceEvent.Payment.GetPaymentMethodId().PaymentType)
+                            });
+                    }
+
+                    await InfoUpdated(paymentId);
+                }
+            }
+            else if (evt is PaymentRequestUpdated updated)
+            {
+                await InfoUpdated(updated.PaymentRequestId);
+
+                var expiry = updated.Data.GetBlob().ExpiryDate;
+                if (updated.Data.Status == PaymentRequestData.PaymentRequestStatus.Pending &&
+                    expiry.HasValue)
+                {
+                    QueueExpiryTask(
+                        updated.PaymentRequestId,
+                        expiry.Value,
+                        cancellationToken);
+                }
+            }
+        }
+
+        private void QueueExpiryTask(string paymentRequestId, DateTime expiry, CancellationToken cancellationToken)
+        {
+            Task.Run(async () =>
+            {
+                var delay = expiry - DateTime.Now;
+                if (delay > TimeSpan.Zero)
+                    await Task.Delay(delay, cancellationToken);
+                await _PaymentRequestService.UpdatePaymentRequestStateIfNeeded(paymentRequestId);
+            }, cancellationToken);
+        }
+
+        private async Task InfoUpdated(string paymentRequestId)
+        {
+            var req = await _PaymentRequestService.GetPaymentRequest(paymentRequestId);
+            if (req != null)
+            {
+                await _HubContext.Clients.Group(paymentRequestId)
+                    .SendCoreAsync(PaymentRequestHub.InfoUpdated, new object[] {req});
+            }
+        }
+    }
+}