bump

Ref: #549, #550

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -34,6 +34,7 @@ using System.Security.Principal;
 using System.Text;
 using System.Threading;
 using Xunit;
+using BTCPayServer.Services;
 
 namespace BTCPayServer.Tests
 {
@@ -121,7 +122,7 @@ namespace BTCPayServer.Tests
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
 
             Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
-            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath });
+            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath, "--disable-registration", "false" });
             _Host = new WebHostBuilder()
                     .UseConfiguration(conf)
                     .ConfigureServices(s =>

BTCPayServer.Tests/CoinSwitchTests.cs

@@ -0,0 +1,89 @@
+using BTCPayServer.Controllers;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.CoinSwitch;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class CoinSwitchTests
+    {
+        public CoinSwitchTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanSetCoinSwitchPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+
+                var storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.Null(storeBlob.CoinSwitchSettings);
+
+                var updateModel = new UpdateCoinSwitchSettingsViewModel()
+                {
+                    MerchantId = "aaa",
+                };
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+                storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.NotNull(storeBlob.CoinSwitchSettings);
+                Assert.NotNull(storeBlob.CoinSwitchSettings);
+                Assert.IsType<CoinSwitchSettings>(storeBlob.CoinSwitchSettings);
+                Assert.Equal(storeBlob.CoinSwitchSettings.MerchantId,
+                    updateModel.MerchantId);
+            }
+        }
+
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanToggleCoinSwitchPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                var updateModel = new UpdateCoinSwitchSettingsViewModel()
+                {
+                    MerchantId = "aaa",
+                    Enabled = true
+                };
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.True(store.GetStoreBlob().CoinSwitchSettings.Enabled);
+
+                updateModel.Enabled = false;
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
+
+                store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.False(store.GetStoreBlob().CoinSwitchSettings.Enabled);
+            }
+        }
+   
+    }
+}

BTCPayServer.Tests/CrowdfundTests.cs

@@ -0,0 +1,303 @@
+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.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;
+using static BTCPayServer.Tests.UnitTest1;
+
+namespace BTCPayServer.Tests
+{
+    public class CrowdfundTests
+    {
+        public CrowdfundTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanCreateAndDeleteCrowdfundApp()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var user2 = tester.NewAccount();
+                user2.GrantAccess();
+                var apps = user.GetController<AppsController>();
+                var apps2 = user2.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                Assert.NotNull(vm.SelectedAppType);
+                Assert.Null(vm.Name);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                Assert.Equal(nameof(apps.UpdateCrowdfund), redirectToAction.ActionName);
+                var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                var appList2 =
+                    Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps2.ListApps().Result).Model);
+                Assert.Single(appList.Apps);
+                Assert.Empty(appList2.Apps);
+                Assert.Equal("test", appList.Apps[0].AppName);
+                Assert.Equal(apps.CreatedAppId, appList.Apps[0].Id);
+                Assert.True(appList.Apps[0].IsOwner);
+                Assert.Equal(user.StoreId, appList.Apps[0].StoreId);
+                Assert.IsType<NotFoundResult>(apps2.DeleteApp(appList.Apps[0].Id).Result);
+                Assert.IsType<ViewResult>(apps.DeleteApp(appList.Apps[0].Id).Result);
+                redirectToAction = Assert.IsType<RedirectToActionResult>(apps.DeleteAppPost(appList.Apps[0].Id).Result);
+                Assert.Equal(nameof(apps.ListApps), redirectToAction.ActionName);
+                appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                Assert.Empty(appList.Apps);
+            }
+        }
+        
+        
+        
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanContributeOnlyWhenAllowed()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
+                    .Apps[0].Id;
+                
+                //Scenario 1: Not Enabled - Not Allowed
+                var crowdfundViewModel = Assert.IsType<UpdateCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(apps.UpdateCrowdfund(appId).Result).Model);
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.Enabled = false;
+                crowdfundViewModel.EndDate = null;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                
+                var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
+                var publicApps = user.GetController<AppsPublicController>();
+
+
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }));
+                
+                Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
+                
+                //Scenario 2: Not Enabled But Admin - Allowed
+                Assert.IsType<OkObjectResult>(await publicApps.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    RedirectToCheckout = false,
+                    Amount = new decimal(0.01)
+                }));
+                Assert.IsType<ViewResult>(await publicApps.ViewCrowdfund(appId, string.Empty));
+                Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
+                
+                //Scenario 3: Enabled But Start Date > Now - Not Allowed
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(2);
+                crowdfundViewModel.Enabled = true;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }));
+                
+                //Scenario 4: Enabled But End Date < Now - Not Allowed
+                
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(-2);
+                crowdfundViewModel.EndDate= DateTime.Today.AddDays(-1);
+                crowdfundViewModel.Enabled = true;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }));
+                
+                
+                //Scenario 5: Enabled and within correct timeframe, however target is enforced and Amount is Over - Not Allowed
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(-2);
+                crowdfundViewModel.EndDate= DateTime.Today.AddDays(2);
+                crowdfundViewModel.Enabled = true;
+                crowdfundViewModel.TargetAmount = 1;
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.EnforceTargetAmount = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(1.01)
+                }));
+                
+                //Scenario 6: Allowed
+                Assert.IsType<OkObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.05)
+                }));
+                
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeCrowdfundModel()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                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;
+                crowdfundViewModel.EndDate = null;
+                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>();
+                var publicApps = user.GetController<AppsPublicController>();
+
+                var model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                
+                
+                Assert.Equal(crowdfundViewModel.TargetAmount, model.TargetAmount );
+                Assert.Equal(crowdfundViewModel.EndDate, model.EndDate );
+                Assert.Equal(crowdfundViewModel.StartDate, model.StartDate );
+                Assert.Equal(crowdfundViewModel.TargetCurrency, model.TargetCurrency );
+                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",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                
+                model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                
+                Assert.Equal(0m ,model.Info.CurrentAmount);
+                Assert.Equal(1m, model.Info.CurrentPendingAmount);
+                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/CustomerHttpServer.cs

@@ -8,30 +8,27 @@ using Microsoft.AspNetCore.Builder;
 using System.Threading.Tasks;
 using System.Threading;
 using Microsoft.AspNetCore.Hosting.Server.Features;
+using System.Threading.Channels;
+using System.IO;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Tests
 {
     public class CustomServer : IDisposable
     {
-        TaskCompletionSource<bool> _Evt = null;
         IWebHost _Host = null;
         CancellationTokenSource _Closed = new CancellationTokenSource();
+        Channel<JObject> _Requests = Channel.CreateUnbounded<JObject>();
         public CustomServer()
-        {
+        { 
             var port = Utils.FreeTcpPort();
             _Host = new WebHostBuilder()
                 .Configure(app =>
                 {
                     app.Run(req =>
                     {
-                        while (_Act == null)
-                        {
-                            Thread.Sleep(10);
-                            _Closed.Token.ThrowIfCancellationRequested();
-                        }
-                        _Act(req);
-                        _Act = null;
-                        _Evt.TrySetResult(true);
+                        _Requests.Writer.WriteAsync(JsonConvert.DeserializeObject<JObject>(new StreamReader(req.Request.Body).ReadToEnd()), _Closed.Token);
                         req.Response.StatusCode = 200;
                         return Task.CompletedTask;
                     });
@@ -47,22 +44,24 @@ namespace BTCPayServer.Tests
             return new Uri(_Host.ServerFeatures.Get<IServerAddressesFeature>().Addresses.First());
         }
 
-        Action<HttpContext> _Act;
-        public void ProcessNextRequest(Action<HttpContext> act)
+        public async Task<JObject> GetNextRequest()
         {
-            var source = new TaskCompletionSource<bool>();
-            CancellationTokenSource cancellation = new CancellationTokenSource(20000);
-            cancellation.Token.Register(() => source.TrySetCanceled());
-            source = new TaskCompletionSource<bool>();
-            _Evt = source;
-            _Act = act;
-            try
+            using (CancellationTokenSource cancellation = new CancellationTokenSource(2000000))
             {
-                _Evt.Task.GetAwaiter().GetResult();
-            }
-            catch (TaskCanceledException)
-            {
-                throw new Xunit.Sdk.XunitException("Callback to the webserver was expected, check if the callback url is accessible from internet");
+                try
+                {
+                    JObject req = null;
+                    while(!await _Requests.Reader.WaitToReadAsync(cancellation.Token) || 
+                        !_Requests.Reader.TryRead(out req))
+                    {
+
+                    }
+                    return req;
+                }
+                catch (TaskCanceledException)
+                {
+                    throw new Xunit.Sdk.XunitException("Callback to the webserver was expected, check if the callback url is accessible from internet");
+                }
             }
         }
 

BTCPayServer.Tests/MockDelay.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Tests
+{
+    public class MockDelay : IDelay
+    {
+        class WaitObj
+        {
+            public DateTimeOffset Expiration;
+            public TaskCompletionSource<bool> CTS;
+        }
+
+        List<WaitObj> waits = new List<WaitObj>();
+        DateTimeOffset _Now = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
+        public async Task Wait(TimeSpan delay, CancellationToken cancellation)
+        {
+            WaitObj w = new WaitObj();
+            w.Expiration = _Now + delay;
+            w.CTS = new TaskCompletionSource<bool>();
+            using (cancellation.Register(() =>
+             {
+                 w.CTS.TrySetCanceled();
+             }))
+            {
+                lock (waits)
+                {
+                    waits.Add(w);
+                }
+                await w.CTS.Task;
+            }
+        }
+
+        public void Advance(TimeSpan time)
+        {
+            _Now += time;
+            lock (waits)
+            {
+                foreach (var wait in waits.ToArray())
+                {
+                    if (_Now >= wait.Expiration)
+                    {
+                        wait.CTS.TrySetResult(true);
+                        waits.Remove(wait);
+                    }
+                }
+            }
+        }
+
+        public void AdvanceMilliseconds(long milli)
+        {
+            Advance(TimeSpan.FromMilliseconds(milli));
+        }
+
+        public override string ToString()
+        {
+            return _Now.Millisecond.ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}

BTCPayServer.Tests/ServerTester.cs

@@ -22,6 +22,7 @@ using BTCPayServer.Tests.Lnd;
 using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Lightning.CLightning;
 using BTCPayServer.Lightning;
+using BTCPayServer.Services;
 
 namespace BTCPayServer.Tests
 {
@@ -152,6 +153,7 @@ namespace BTCPayServer.Tests
         {
             get; set;
         }
+
         public List<string> Stores { get; internal set; } = new List<string>();
 
         public void Dispose()

BTCPayServer.Tests/TestAccount.cs

@@ -17,6 +17,7 @@ using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Tests.Logging;
 using BTCPayServer.Lightning;
 using BTCPayServer.Lightning.CLightning;
+using BTCPayServer.Data;
 
 namespace BTCPayServer.Tests
 {
@@ -58,6 +59,21 @@ namespace BTCPayServer.Tests
             CreateStoreAsync().GetAwaiter().GetResult();
         }
 
+        public void SetNetworkFeeMode(NetworkFeeMode mode)
+        {
+            ModifyStore((store) =>
+            {
+                store.NetworkFeeMode = mode;
+            });
+        }
+        public void ModifyStore(Action<StoreViewModel> modify)
+        {
+            var storeController = GetController<StoresController>();
+            StoreViewModel store = (StoreViewModel)((ViewResult)storeController.UpdateStore()).Model;
+            modify(store);
+            storeController.UpdateStore(store).GetAwaiter().GetResult();
+        }
+
         public T GetController<T>(bool setImplicitStore = true) where T : Controller
         {
             return parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null);
@@ -83,10 +99,6 @@ namespace BTCPayServer.Tests
             var store = parent.PayTester.GetController<StoresController>(UserId, StoreId);
             ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
             DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + (segwit ? "" : "-[legacy]"));
-            var vm = (StoreViewModel)((ViewResult)store.UpdateStore()).Model;
-            vm.SpeedPolicy = SpeedPolicy.MediumSpeed;
-            await store.UpdateStore(vm);
-
             await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
             {
                 DerivationScheme = DerivationScheme.ToString(),

BTCPayServer.Tests/UnitTest1.cs

@@ -49,6 +49,9 @@ using BTCPayServer.Security;
 using NBXplorer.Models;
 using RatesViewModel = BTCPayServer.Models.StoreViewModels.RatesViewModel;
 using NBitpayClient.Extensions;
+using BTCPayServer.Services;
+using System.Text.RegularExpressions;
+using BTCPayServer.Events;
 
 namespace BTCPayServer.Tests
 {
@@ -98,7 +101,7 @@ namespace BTCPayServer.Tests
                 Rate = 10513.44m,
             }.SetPaymentMethodDetails(new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
             {
-                TxFee = Money.Coins(0.00000100m),
+                NextNetworkFee = Money.Coins(0.00000100m),
                 DepositAddress = dummy
             }));
             paymentMethods.Add(new PaymentMethod()
@@ -107,7 +110,7 @@ namespace BTCPayServer.Tests
                 Rate = 216.79m
             }.SetPaymentMethodDetails(new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
             {
-                TxFee = Money.Coins(0.00010000m),
+                NextNetworkFee = Money.Coins(0.00010000m),
                 DepositAddress = dummy
             }));
             invoiceEntity.SetPaymentMethods(paymentMethods);
@@ -115,12 +118,12 @@ namespace BTCPayServer.Tests
             var btc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
             var accounting = btc.Calculate();
 
-            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC" }.SetCryptoPaymentData(new BitcoinLikePaymentData()
+            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC", NetworkFee = 0.00000100m }.SetCryptoPaymentData(new BitcoinLikePaymentData()
             {
                 Output = new TxOut() { Value = Money.Coins(0.00151263m) }
             }));
             accounting = btc.Calculate();
-            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC" }.SetCryptoPaymentData(new BitcoinLikePaymentData()
+            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC", NetworkFee = 0.00000100m }.SetCryptoPaymentData(new BitcoinLikePaymentData()
             {
                 Output = new TxOut() { Value = accounting.Due }
             }));
@@ -147,7 +150,7 @@ namespace BTCPayServer.Tests
             var entity = new InvoiceEntity();
 #pragma warning disable CS0618
             entity.Payments = new System.Collections.Generic.List<PaymentEntity>();
-            entity.SetPaymentMethod(new PaymentMethod() { CryptoCode = "BTC", Rate = 5000, TxFee = Money.Coins(0.1m) });
+            entity.SetPaymentMethod(new PaymentMethod() { CryptoCode = "BTC", Rate = 5000, NextNetworkFee = Money.Coins(0.1m) });
             entity.ProductInformation = new ProductInformation() { Price = 5000 };
 
             var paymentMethod = entity.GetPaymentMethods(null).TryGet("BTC", PaymentTypes.BTCLike);
@@ -155,20 +158,20 @@ namespace BTCPayServer.Tests
             Assert.Equal(Money.Coins(1.1m), accounting.Due);
             Assert.Equal(Money.Coins(1.1m), accounting.TotalDue);
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.5m), new Key()), Accounted = true });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.5m), new Key()), Accounted = true, NetworkFee = 0.1m });
 
             accounting = paymentMethod.Calculate();
             //Since we need to spend one more txout, it should be 1.1 - 0,5 + 0.1
             Assert.Equal(Money.Coins(0.7m), accounting.Due);
             Assert.Equal(Money.Coins(1.2m), accounting.TotalDue);
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true, NetworkFee = 0.1m });
 
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(0.6m), accounting.Due);
             Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.6m), new Key()), Accounted = true });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.6m), new Key()), Accounted = true, NetworkFee = 0.1m });
 
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
@@ -187,13 +190,13 @@ namespace BTCPayServer.Tests
             {
                 CryptoCode = "BTC",
                 Rate = 1000,
-                TxFee = Money.Coins(0.1m)
+                NextNetworkFee = Money.Coins(0.1m)
             });
             paymentMethods.Add(new PaymentMethod()
             {
                 CryptoCode = "LTC",
                 Rate = 500,
-                TxFee = Money.Coins(0.01m)
+                NextNetworkFee = Money.Coins(0.01m)
             });
             entity.SetPaymentMethods(paymentMethods);
             entity.Payments = new List<PaymentEntity>();
@@ -205,7 +208,7 @@ namespace BTCPayServer.Tests
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(10.01m), accounting.TotalDue);
 
-            entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true });
+            entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true, NetworkFee = 0.1m });
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
             accounting = paymentMethod.Calculate();
@@ -222,7 +225,7 @@ namespace BTCPayServer.Tests
             Assert.Equal(Money.Coins(2.0m), accounting.Paid);
             Assert.Equal(Money.Coins(10.01m + 0.1m * 2), accounting.TotalDue);
 
-            entity.Payments.Add(new PaymentEntity() { CryptoCode = "LTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true });
+            entity.Payments.Add(new PaymentEntity() { CryptoCode = "LTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true, NetworkFee = 0.01m });
 
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
@@ -242,7 +245,7 @@ namespace BTCPayServer.Tests
             Assert.Equal(2, accounting.TxRequired);
 
             var remaining = Money.Coins(4.2m - 0.5m + 0.01m / 2);
-            entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(remaining, new Key()), Accounted = true });
+            entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(remaining, new Key()), Accounted = true, NetworkFee = 0.1m });
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
             accounting = paymentMethod.Calculate();
@@ -272,7 +275,7 @@ namespace BTCPayServer.Tests
             var entity = new InvoiceEntity();
 #pragma warning disable CS0618
             entity.Payments = new List<PaymentEntity>();
-            entity.SetPaymentMethod(new PaymentMethod() { CryptoCode = "BTC", Rate = 5000, TxFee = Money.Coins(0.1m) });
+            entity.SetPaymentMethod(new PaymentMethod() { CryptoCode = "BTC", Rate = 5000, NextNetworkFee = Money.Coins(0.1m) });
             entity.ProductInformation = new ProductInformation() { Price = 5000 };
             entity.PaymentTolerance = 0;
 
@@ -326,7 +329,7 @@ namespace BTCPayServer.Tests
                 var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
                 tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Satoshis((decimal)invoice.BtcDue.Satoshi * 0.75m));
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
@@ -349,7 +352,7 @@ namespace BTCPayServer.Tests
                 (1000.0001m, "₹ 1,000.00 (INR)", "INR")
             })
             {
-                var actual = new CurrencyNameTable().DisplayFormatCurrency(test.Item1, test.Item3);                
+                var actual = new CurrencyNameTable().DisplayFormatCurrency(test.Item1, test.Item3);
                 actual = actual.Replace("￥", "¥"); // Hack so JPY test pass on linux as well
                 Assert.Equal(test.Item2, actual);
             }
@@ -448,7 +451,7 @@ namespace BTCPayServer.Tests
             });
             await Task.Delay(TimeSpan.FromMilliseconds(1000)); // Give time to listen the new invoices
             await tester.SendLightningPaymentAsync(invoice);
-            await EventuallyAsync(async () =>
+            await TestUtils.EventuallyAsync(async () =>
             {
                 var localInvoice = await user.BitPay.GetInvoiceAsync(invoice.Id);
                 Assert.Equal("complete", localInvoice.Status);
@@ -484,7 +487,7 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanSendIPN()
+        public async Task CanSendIPN()
         {
             using (var callbackServer = new CustomServer())
             {
@@ -494,6 +497,7 @@ namespace BTCPayServer.Tests
                     var acc = tester.NewAccount();
                     acc.GrantAccess();
                     acc.RegisterDerivationScheme("BTC");
+                    acc.ModifyStore(s => s.SpeedPolicy = SpeedPolicy.LowSpeed);
                     var invoice = acc.BitPay.CreateInvoice(new Invoice()
                     {
                         Price = 5.0m,
@@ -506,13 +510,43 @@ namespace BTCPayServer.Tests
                         ExtendedNotifications = true
                     });
                     BitcoinUrlBuilder url = new BitcoinUrlBuilder(invoice.PaymentUrls.BIP21);
-                    tester.ExplorerNode.SendToAddress(url.Address, url.Amount);
-                    Thread.Sleep(5000);
-                    callbackServer.ProcessNextRequest((ctx) =>
+                    bool receivedPayment = false;
+                    bool paid = false;
+                    bool confirmed = false;
+                    bool completed = false;
+                    while (!completed || !confirmed)
                     {
-                        var ipn = new StreamReader(ctx.Request.Body).ReadToEnd();
-                        JsonConvert.DeserializeObject<InvoicePaymentNotification>(ipn); //can deserialize
-                    });
+                        var request = await callbackServer.GetNextRequest();
+                        if (request.ContainsKey("event"))
+                        {
+                            var evtName = request["event"]["name"].Value<string>();
+                            switch (evtName)
+                            {
+                                case InvoiceEvent.Created:
+                                    tester.ExplorerNode.SendToAddress(url.Address, url.Amount);
+                                    break;
+                                case InvoiceEvent.ReceivedPayment:
+                                    receivedPayment = true;
+                                    break;
+                                case InvoiceEvent.PaidInFull:
+                                    Assert.True(receivedPayment);
+                                    tester.ExplorerNode.Generate(6);
+                                    paid = true;
+                                    break;
+                                case InvoiceEvent.Confirmed:
+                                    Assert.True(paid);
+                                    confirmed = true;
+                                    break;
+                                case InvoiceEvent.Completed:
+                                    Assert.True(paid); //TODO: Fix, out of order event mean we can receive invoice_confirmed after invoice_complete
+                                    completed = true;
+                                    break;
+                                default:
+                                    Assert.False(true, $"{evtName} was not expected");
+                                    break;
+                            }
+                        }
+                    }
                     var invoice2 = acc.BitPay.GetInvoice(invoice.Id);
                     Assert.NotNull(invoice2);
                 }
@@ -651,7 +685,7 @@ namespace BTCPayServer.Tests
                 var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
                 var firstPayment = invoice.CryptoInfo[0].TotalDue - Money.Satoshis(10);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = acc.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(firstPayment, invoice.CryptoInfo[0].Paid);
@@ -726,6 +760,7 @@ namespace BTCPayServer.Tests
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
+                user.SetNetworkFeeMode(NetworkFeeMode.Always);
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 5000.0m,
@@ -747,7 +782,7 @@ namespace BTCPayServer.Tests
                 var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, user.SupportedNetwork.NBitcoinNetwork);
 
                 Logs.Tester.LogInformation($"The invoice should be paidOver");
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment1, invoice.BtcPaid);
@@ -776,7 +811,7 @@ namespace BTCPayServer.Tests
                     Assert.Equal(tx2, ((NewTransactionEvent)listener.NextEvent(cts.Token)).TransactionData.TransactionHash);
                 }
                 Logs.Tester.LogInformation($"The invoice should now not be paidOver anymore");
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment2, invoice.BtcPaid);
@@ -824,6 +859,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()
@@ -1023,7 +1096,7 @@ namespace BTCPayServer.Tests
                 var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
                 var firstPayment = Money.Coins(0.1m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(firstPayment, invoice.CryptoInfo[0].Paid);
@@ -1044,7 +1117,7 @@ namespace BTCPayServer.Tests
                 Assert.NotEqual(invoice.BtcDue, invoice.CryptoInfo[0].Due); // Should be BTC rate
                 cashCow.SendToAddress(invoiceAddress, invoice.CryptoInfo[0].Due);
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal("paid", invoice.Status);
@@ -1142,7 +1215,7 @@ namespace BTCPayServer.Tests
                 var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
                 var firstPayment = Money.Coins(0.04m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.True(invoice.BtcPaid == firstPayment);
@@ -1184,7 +1257,7 @@ namespace BTCPayServer.Tests
                 firstPayment = Money.Coins(0.04m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
                 Logs.Tester.LogInformation("First payment sent to " + invoiceAddress);
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.True(invoice.BtcPaid == firstPayment);
@@ -1198,7 +1271,7 @@ namespace BTCPayServer.Tests
                 cashCow.Generate(2); // LTC is not worth a lot, so just to make sure we have money...
                 cashCow.SendToAddress(invoiceAddress, secondPayment);
                 Logs.Tester.LogInformation("Second payment sent to " + invoiceAddress);
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(Money.Zero, invoice.BtcDue);
@@ -1225,6 +1298,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"));
             }
         }
 
@@ -1429,6 +1521,7 @@ namespace BTCPayServer.Tests
                 vmpos.ButtonText = "{0} Purchase";
                 vmpos.CustomButtonText = "Nicolas Sexy Hair";
                 vmpos.CustomTipText = "Wanna tip?";
+                vmpos.CustomTipPercentages = "15,18,20";
                 vmpos.Template = @"
 apple:
   price: 5.0
@@ -1454,6 +1547,7 @@ donation:
                 Assert.Equal("{0} Purchase", vmview.ButtonText);
                 Assert.Equal("Nicolas Sexy Hair", vmview.CustomButtonText);
                 Assert.Equal("Wanna tip?", vmview.CustomTipText);
+                Assert.Equal("15,18,20", string.Join(',', vmview.CustomTipPercentages));
                 Assert.IsType<RedirectToActionResult>(publicApps.ViewPointOfSale(appId, 0, null, null, null, null, "orange").Result);
 
                 //
@@ -1512,23 +1606,96 @@ donation:
             }
         }
 
+
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void 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));
+            Logs.Tester.LogInformation("Start Job[1] in 2 sec");
+            client.Schedule(async () => { Logs.Tester.LogInformation("Job[1]"); jobs[1] = true; }, 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));
+            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));
+
+            Assert.True(new[] { false, false, false, false }.SequenceEqual(jobs));
+            CancellationTokenSource cts = new CancellationTokenSource();
+            var processing = client.ProcessJobs(cts.Token);
+
+            Assert.Equal(4, client.GetExecutingCount());
+
+            var waitJobsFinish = client.WaitAllRunning(default);
+
+            mockDelay.Advance(TimeSpan.FromSeconds(2.0));
+            Assert.True(new[] { false, true, false, false }.SequenceEqual(jobs));
+
+            mockDelay.Advance(TimeSpan.FromSeconds(3.0));
+            Assert.True(new[] { true, true, false, false }.SequenceEqual(jobs));
+
+            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.IsCompletedSuccessfully);
+
+            mockDelay.Advance(TimeSpan.FromSeconds(1.0));
+            Assert.True(new[] { true, true, true, true }.SequenceEqual(jobs));
+
+            Assert.True(waitJobsFinish.Wait(100));
+            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));
+            Assert.False(jobExecuted);
+            Thread.Sleep(100);
+            Assert.Equal(1, client.GetExecutingCount());
+
+
+            waitJobsFinish = client.WaitAllRunning(default);
+            Assert.False(waitJobsFinish.Wait(100));
+            cts.Cancel();
+            Assert.True(waitJobsFinish.Wait(1000));
+            Assert.True(waitJobsFinish.IsCompletedSuccessfully);
+            Assert.True(!waitJobsFinish.IsFaulted);
+            Assert.False(jobExecuted);
+
+            mockDelay.Advance(TimeSpan.FromSeconds(1.0));
+            Thread.Sleep(100); // Make sure it get cancelled
+
+            Assert.False(jobExecuted);
+            Assert.Equal(0, client.GetExecutingCount());
+            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]
         [Trait("Fast", "Fast")]
         public void PosDataParser_ParsesCorrectly()
         {
             var testCases =
-                new List<(string input, Dictionary<string, string> expectedOutput)>()
+                new List<(string input, Dictionary<string, object> expectedOutput)>()
                 {
-                    { (null, new Dictionary<string, string>())},
-                    {("", new Dictionary<string, string>())},
-                    {("{}", new Dictionary<string, string>())},
-                    {("non-json-content", new Dictionary<string, string>(){ {string.Empty, "non-json-content"}})},
-                    {("[1,2,3]", new Dictionary<string, string>(){ {string.Empty, "[1,2,3]"}})},
-                    {("{ \"key\": \"value\"}", new Dictionary<string, string>(){ {"key", "value"}})},
-                    {("{ \"key\": true}", new Dictionary<string, string>(){ {"key", "True"}})},
-                    {("{ \"key\": \"value\", \"key2\": [\"value\", \"value2\"]}",
-                        new Dictionary<string, string>(){ {"key", "value"}, {"key2", "value,value2"}})},
-                    {("{ invalidjson file here}", new Dictionary<string, string>(){ {String.Empty, "{ invalidjson file here}"}})}
+                    { (null, new Dictionary<string, object>())},
+                    {("", new Dictionary<string, object>())},
+                    {("{}", new Dictionary<string, object>())},
+                    {("non-json-content", new Dictionary<string, object>(){ {string.Empty, "non-json-content"}})},
+                    {("[1,2,3]", new Dictionary<string, object>(){ {string.Empty, "[1,2,3]"}})},
+                    {("{ \"key\": \"value\"}", new Dictionary<string, object>(){ {"key", "value"}})},
+                    {("{ \"key\": true}", new Dictionary<string, object>(){ {"key", "True"}})},
+                    {("{ invalidjson file here}", new Dictionary<string, object>(){ {String.Empty, "{ invalidjson file here}"}})}
                 };
 
             testCases.ForEach(tuple =>
@@ -1551,18 +1718,16 @@ donation:
                 var controller = tester.PayTester.GetController<InvoiceController>(null);
 
                 var testCases =
-                    new List<(string input, Dictionary<string, string> expectedOutput)>()
+                    new List<(string input, Dictionary<string, object> expectedOutput)>()
                     {
-                        { (null, new Dictionary<string, string>())},
-                        {("", new Dictionary<string, string>())},
-                        {("{}", new Dictionary<string, string>())},
-                        {("non-json-content", new Dictionary<string, string>(){ {string.Empty, "non-json-content"}})},
-                        {("[1,2,3]", new Dictionary<string, string>(){ {string.Empty, "[1,2,3]"}})},
-                        {("{ \"key\": \"value\"}", new Dictionary<string, string>(){ {"key", "value"}})},
-                        {("{ \"key\": true}", new Dictionary<string, string>(){ {"key", "True"}})},
-                        {("{ \"key\": \"value\", \"key2\": [\"value\", \"value2\"]}",
-                        new Dictionary<string, string>(){ {"key", "value"}, {"key2", "value,value2"}})},
-                        {("{ invalidjson file here}", new Dictionary<string, string>(){ {String.Empty, "{ invalidjson file here}"}})}
+                        { (null, new Dictionary<string, object>())},
+                        {("", new Dictionary<string, object>())},
+                        {("{}", new Dictionary<string, object>())},
+                        {("non-json-content", new Dictionary<string, object>(){ {string.Empty, "non-json-content"}})},
+                        {("[1,2,3]", new Dictionary<string, object>(){ {string.Empty, "[1,2,3]"}})},
+                        {("{ \"key\": \"value\"}", new Dictionary<string, object>(){ {"key", "value"}})},
+                        {("{ \"key\": true}", new Dictionary<string, object>(){ {"key", "True"}})},
+                        {("{ invalidjson file here}", new Dictionary<string, object>(){ {String.Empty, "{ invalidjson file here}"}})}
                     };
 
                 var tasks = new List<Task>();
@@ -1589,16 +1754,22 @@ donation:
         [Trait("Integration", "Integration")]
         public void CanExportInvoicesJson()
         {
+            decimal GetFieldValue(string input, string fieldName)
+            {
+                var match = Regex.Match(input, $"\"{fieldName}\":([^,]*)");
+                Assert.True(match.Success);
+                return decimal.Parse(match.Groups[1].Value.Trim(), CultureInfo.InvariantCulture);
+            }
             using (var tester = ServerTester.Create())
             {
                 tester.Start();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
-
+                user.SetNetworkFeeMode(NetworkFeeMode.Always);
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
-                    Price = 500,
+                    Price = 10,
                     Currency = "USD",
                     PosData = "posData",
                     OrderId = "orderId",
@@ -1606,6 +1777,7 @@ donation:
                     FullNotifications = true
                 }, Facade.Merchant);
 
+                var networkFee = new FeeRate(invoice.MinerFees["BTC"].SatoshiPerBytes).GetFee(100);
                 // ensure 0 invoices exported because there are no payments yet
                 var jsonResult = user.GetController<InvoiceController>().Export("json").GetAwaiter().GetResult();
                 var result = Assert.IsType<ContentResult>(jsonResult);
@@ -1614,46 +1786,123 @@ donation:
 
                 var cashCow = tester.ExplorerNode;
                 var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
-                var firstPayment = invoice.CryptoInfo[0].TotalDue - Money.Satoshis(10);
+                // 
+                var firstPayment = invoice.CryptoInfo[0].TotalDue - 3 * networkFee;
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
+                Thread.Sleep(1000); // prevent race conditions, ordering payments
+                // look if you can reduce thread sleep, this was min value for me
 
-                Eventually(() =>
+                // should reduce invoice due by 0 USD because payment = network fee
+                cashCow.SendToAddress(invoiceAddress, networkFee);
+                Thread.Sleep(1000);
+
+                // pay remaining amount
+                cashCow.SendToAddress(invoiceAddress, 4 * networkFee);
+                Thread.Sleep(1000);
+
+                TestUtils.Eventually(() =>
                 {
                     var jsonResultPaid = user.GetController<InvoiceController>().Export("json").GetAwaiter().GetResult();
                     var paidresult = Assert.IsType<ContentResult>(jsonResultPaid);
                     Assert.Equal("application/json", paidresult.ContentType);
-                    Assert.Contains("\"InvoiceItemDesc\": \"Some \\\", description\"", paidresult.Content);
-                    Assert.Contains("\"InvoicePrice\": 500.0", paidresult.Content);
-                    Assert.Contains("\"ConversionRate\": 5000.0", paidresult.Content);
-                    Assert.Contains($"\"InvoiceId\": \"{invoice.Id}\",", paidresult.Content);
-                });
 
-                /*
-[
-  {
-    "ReceivedDate": "2018-11-30T10:27:13Z",
-    "StoreId": "FKaSZrXLJ2tcLfCyeiYYfmZp1UM5nZ1LDecQqbwBRuHi",
-    "OrderId": "orderId",
-    "InvoiceId": "4XUkgPMaTBzwJGV9P84kPC",
-    "CreatedDate": "2018-11-30T10:27:06Z",
-    "ExpirationDate": "2018-11-30T10:42:06Z",
-    "MonitoringDate": "2018-11-30T11:42:06Z",
-    "PaymentId": "6e5755c3357b20fd66f5fc478778d81371eab341e7112ab66ed6122c0ec0d9e5-1",
-    "CryptoCode": "BTC",
-    "Destination": "mhhSEQuoM993o6vwnBeufJ4TaWov2ZUsPQ",
-    "PaymentType": "OnChain",
-    "PaymentDue": "0.10020000 BTC",
-    "PaymentPaid": "0.10009990 BTC",
-    "PaymentOverpaid": "0.00000000 BTC",
-    "ConversionRate": 5000.0,
-    "FiatPrice": 500.0,
-    "FiatCurrency": "USD",
-    "ItemCode": null,
-    "ItemDesc": "Some \", description",
-    "Status": "new"
-  }
-]
-                */
+                    var parsedJson = JsonConvert.DeserializeObject<object[]>(paidresult.Content);
+                    Assert.Equal(3, parsedJson.Length);
+
+                    var invoiceDueAfterFirstPayment = (3 * networkFee).ToDecimal(MoneyUnit.BTC) * invoice.Rate;
+                    var pay1str = parsedJson[0].ToString();
+                    Assert.Contains("\"InvoiceItemDesc\": \"Some \\\", description\"", pay1str);
+                    Assert.Equal(invoiceDueAfterFirstPayment, GetFieldValue(pay1str, "InvoiceDue"));
+                    Assert.Contains("\"InvoicePrice\": 10.0", pay1str);
+                    Assert.Contains("\"ConversionRate\": 5000.0", pay1str);
+                    Assert.Contains($"\"InvoiceId\": \"{invoice.Id}\",", pay1str);
+
+                    var pay2str = parsedJson[1].ToString();
+                    Assert.Equal(invoiceDueAfterFirstPayment, GetFieldValue(pay2str, "InvoiceDue"));
+
+                    var pay3str = parsedJson[2].ToString();
+                    Assert.Contains("\"InvoiceDue\": 0", pay3str);
+                });
+            }
+        }
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanChangeNetworkFeeMode()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                foreach (var networkFeeMode in Enum.GetValues(typeof(NetworkFeeMode)).Cast<NetworkFeeMode>())
+                {
+                    Logs.Tester.LogInformation($"Trying with {nameof(networkFeeMode)}={networkFeeMode}");
+                    user.SetNetworkFeeMode(networkFeeMode);
+                    var invoice = user.BitPay.CreateInvoice(new Invoice()
+                    {
+                        Price = 10,
+                        Currency = "USD",
+                        PosData = "posData",
+                        OrderId = "orderId",
+                        ItemDesc = "Some \", description",
+                        FullNotifications = true
+                    }, Facade.Merchant);
+
+                    var networkFee = Money.Satoshis(10000).ToDecimal(MoneyUnit.BTC);
+                    var missingMoney = Money.Satoshis(5000).ToDecimal(MoneyUnit.BTC);
+                    var cashCow = tester.ExplorerNode;
+                    var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
+
+                    // Check that for the first payment, no network fee are included
+                    var due = Money.Parse(invoice.CryptoInfo[0].Due);
+                    var productPartDue = (invoice.Price / invoice.Rate);
+                    switch (networkFeeMode)
+                    {
+                        case NetworkFeeMode.MultiplePaymentsOnly:
+                        case NetworkFeeMode.Never:
+                            Assert.Equal(productPartDue, due.ToDecimal(MoneyUnit.BTC));
+                            break;
+                        case NetworkFeeMode.Always:
+                            Assert.Equal(productPartDue + networkFee, due.ToDecimal(MoneyUnit.BTC));
+                            break;
+                        default:
+                            throw new NotSupportedException(networkFeeMode.ToString());
+                    }
+                    var firstPayment = productPartDue - missingMoney;
+                    cashCow.SendToAddress(invoiceAddress, Money.Coins(firstPayment));
+
+                    TestUtils.Eventually(() =>
+                    {
+                        invoice = user.BitPay.GetInvoice(invoice.Id);
+                        // Check that for the second payment, network fee are included
+                        due = Money.Parse(invoice.CryptoInfo[0].Due);
+                        Assert.Equal(Money.Coins(firstPayment), Money.Parse(invoice.CryptoInfo[0].Paid));
+                        switch (networkFeeMode)
+                        {
+                            case NetworkFeeMode.MultiplePaymentsOnly:
+                                Assert.Equal(missingMoney + networkFee, due.ToDecimal(MoneyUnit.BTC));
+                                Assert.Equal(firstPayment + missingMoney + networkFee, Money.Parse(invoice.CryptoInfo[0].TotalDue).ToDecimal(MoneyUnit.BTC));
+                                break;
+                            case NetworkFeeMode.Always:
+                                Assert.Equal(missingMoney + 2 * networkFee, due.ToDecimal(MoneyUnit.BTC));
+                                Assert.Equal(firstPayment + missingMoney + 2 * networkFee, Money.Parse(invoice.CryptoInfo[0].TotalDue).ToDecimal(MoneyUnit.BTC));
+                                break;
+                            case NetworkFeeMode.Never:
+                                Assert.Equal(missingMoney, due.ToDecimal(MoneyUnit.BTC));
+                                Assert.Equal(firstPayment + missingMoney, Money.Parse(invoice.CryptoInfo[0].TotalDue).ToDecimal(MoneyUnit.BTC));
+                                break;
+                            default:
+                                throw new NotSupportedException(networkFeeMode.ToString());
+                        }
+                    });
+                    cashCow.SendToAddress(invoiceAddress, due);
+                    TestUtils.Eventually(() =>
+                    {
+                        invoice = user.BitPay.GetInvoice(invoice.Id);
+                        Assert.Equal("paid", invoice.Status);
+                    });
+                }
             }
         }
 
@@ -1667,7 +1916,7 @@ donation:
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
-
+                user.SetNetworkFeeMode(NetworkFeeMode.Always);
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 500,
@@ -1680,17 +1929,18 @@ donation:
 
                 var cashCow = tester.ExplorerNode;
                 var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
-                var firstPayment = invoice.CryptoInfo[0].TotalDue - Money.Satoshis(10);
+                var firstPayment = invoice.CryptoInfo[0].TotalDue - Money.Coins(0.001m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var exportResultPaid = user.GetController<InvoiceController>().Export("csv").GetAwaiter().GetResult();
                     var paidresult = Assert.IsType<ContentResult>(exportResultPaid);
                     Assert.Equal("application/csv", paidresult.ContentType);
                     Assert.Contains($",\"orderId\",\"{invoice.Id}\",", paidresult.Content);
-                    Assert.Contains($",\"OnChain\",\"0.1000999\",\"BTC\",\"5000.0\",\"500.0\"", paidresult.Content);
-                    Assert.Contains($",\"USD\",\"\",\"Some ``, description\",\"new (paidPartial)\"", paidresult.Content);
+                    Assert.Contains($",\"OnChain\",\"BTC\",\"0.0991\",\"0.0001\",\"5000.0\"", paidresult.Content);
+                    Assert.Contains($",\"USD\",\"5.00", paidresult.Content); // Seems hacky but some plateform does not render this decimal the same
+                    Assert.Contains($"0\",\"500.0\",\"\",\"Some ``, description\",\"new (paidPartial)\"", paidresult.Content);
                 });
             }
         }
@@ -1734,6 +1984,50 @@ donation:
             }
         }
 
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanCreateStrangeInvoice()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var invoice1 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 0.000000012m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                var invoice2 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 0.000000019m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                Assert.Equal(0.00000001m, invoice1.Price);
+                Assert.Equal(0.00000002m, invoice2.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);
+            }
+        }
+
         [Fact]
         [Trait("Integration", "Integration")]
         public void InvoiceFlowThroughDifferentStatesCorrectly()
@@ -1747,6 +2041,7 @@ donation:
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 5000.0m,
+                    TaxIncluded = 1000.0m,
                     Currency = "USD",
                     PosData = "posData",
                     OrderId = "orderId",
@@ -1758,7 +2053,7 @@ donation:
                 Assert.Equal(0, invoice.CryptoInfo[0].TxCount);
                 Assert.True(invoice.MinerFees.ContainsKey("BTC"));
                 Assert.Contains(invoice.MinerFees["BTC"].SatoshiPerBytes, new[] { 100.0m, 20.0m });
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var textSearchResult = tester.PayTester.InvoiceRepository.GetInvoices(new InvoiceQuery()
                     {
@@ -1776,6 +2071,8 @@ donation:
                 });
 
                 invoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+                Assert.Equal(1000.0m, invoice.TaxIncluded);
+                Assert.Equal(5000.0m, invoice.Price);
                 Assert.Equal(Money.Coins(0), invoice.BtcPaid);
                 Assert.Equal("new", invoice.Status);
                 Assert.False((bool)((JValue)invoice.ExceptionStatus).Value);
@@ -1804,7 +2101,7 @@ donation:
 
                 Money secondPayment = Money.Zero;
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("new", localInvoice.Status);
@@ -1827,7 +2124,7 @@ donation:
 
                 cashCow.SendToAddress(invoiceAddress, secondPayment);
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
@@ -1841,7 +2138,7 @@ donation:
 
                 cashCow.Generate(1); //The user has medium speed settings, so 1 conf is enough to be confirmed
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("confirmed", localInvoice.Status);
@@ -1849,7 +2146,7 @@ donation:
 
                 cashCow.Generate(5); //Now should be complete
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("complete", localInvoice.Status);
@@ -1871,7 +2168,7 @@ donation:
 
                 var txId = cashCow.SendToAddress(invoiceAddress, invoice.BtcDue + Money.Coins(1));
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
@@ -1888,7 +2185,7 @@ donation:
 
                 cashCow.Generate(1);
 
-                Eventually(() =>
+                TestUtils.Eventually(() =>
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("confirmed", localInvoice.Status);
@@ -1898,19 +2195,20 @@ donation:
             }
         }
 
-        [Fact]
-        [Trait("Integration", "Integration")]
-        public void CheckQuadrigacxRateProvider()
-        {
-            var quadri = new QuadrigacxRateProvider();
-            var rates = quadri.GetRatesAsync().GetAwaiter().GetResult();
-            Assert.NotEmpty(rates);
-            Assert.NotEqual(0.0m, rates.First().BidAsk.Bid);
-            Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("BTC_CAD")).Bid);
-            Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("BTC_USD")).Bid);
-            Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("LTC_CAD")).Bid);
-            Assert.Null(rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("LTC_USD")));
-        }
+        //[Fact]
+        //[Trait("Integration", "Integration")]
+        // 29 january, the exchange is down
+        //public void CheckQuadrigacxRateProvider()
+        //{
+        //    var quadri = new QuadrigacxRateProvider();
+        //    var rates = quadri.GetRatesAsync().GetAwaiter().GetResult();
+        //    Assert.NotEmpty(rates);
+        //    Assert.NotEqual(0.0m, rates.First().BidAsk.Bid);
+        //    Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("BTC_CAD")).Bid);
+        //    Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("BTC_USD")).Bid);
+        //    Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("LTC_CAD")).Bid);
+        //    Assert.Null(rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("LTC_USD")));
+        //}
 
         [Fact]
         [Trait("Integration", "Integration")]
@@ -1924,6 +2222,9 @@ donation:
                 .Select(p => (ExpectedName: p.Key, ResultAsync: p.Value.GetRatesAsync(), Fetcher: (BackgroundFetcherRateProvider)p.Value))
                 .ToList())
             {
+                Logs.Tester.LogInformation($"Testing {result.ExpectedName}");
+                if (result.ExpectedName == "quadrigacx")
+                    continue; // 29 january, the exchange is down
                 result.Fetcher.InvalidateCache();
                 var exchangeRates = result.ResultAsync.Result;
                 result.Fetcher.InvalidateCache();
@@ -2072,42 +2373,81 @@ donation:
             Assert.Throws<InvalidOperationException>(() => fetch.GetRatesAsync().GetAwaiter().GetResult());
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void CheckParseStatusMessageModel()
+        {
+            var legacyStatus = "Error: some bad shit happened";
+            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);
+            Assert.Equal(StatusMessageModel.StatusSeverity.Success, parsed.Severity);
+
+            var newStatus = new StatusMessageModel()
+            {
+                Html = "<a href='xxx'>something new</a>",
+                Severity = StatusMessageModel.StatusSeverity.Info
+            };
+            parsed = new StatusMessageModel(newStatus.ToString());
+            Assert.Null(parsed.Message);
+            Assert.Equal(newStatus.Html, parsed.Html);
+            Assert.Equal(StatusMessageModel.StatusSeverity.Info, parsed.Severity);
+
+            var newStatus2 = new StatusMessageModel()
+            {
+                Message = "something new",
+                Severity = StatusMessageModel.StatusSeverity.Success
+            };
+            parsed = new StatusMessageModel(newStatus2.ToString());
+            Assert.Null(parsed.Html);
+            Assert.Equal(newStatus2.Message, parsed.Message);
+            Assert.Equal(StatusMessageModel.StatusSeverity.Success, parsed.Severity);
+
+        }
+
         private static bool IsMapped(Invoice invoice, ApplicationDbContext ctx)
         {
             var h = BitcoinAddress.Create(invoice.BitcoinAddress, Network.RegTest).ScriptPubKey.Hash.ToString();
             return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetAddress() == h) != null;
         }
 
-        private void Eventually(Action act)
+        public static class TestUtils
         {
-            CancellationTokenSource cts = new CancellationTokenSource(20000);
-            while (true)
+            public static void Eventually(Action act)
             {
-                try
+                CancellationTokenSource cts = new CancellationTokenSource(20000);
+                while (true)
                 {
-                    act();
-                    break;
-                }
-                catch (XunitException) when (!cts.Token.IsCancellationRequested)
-                {
-                    cts.Token.WaitHandle.WaitOne(500);
+                    try
+                    {
+                        act();
+                        break;
+                    }
+                    catch (XunitException) when (!cts.Token.IsCancellationRequested)
+                    {
+                        cts.Token.WaitHandle.WaitOne(500);
+                    }
                 }
             }
-        }
 
-        private async Task EventuallyAsync(Func<Task> act)
-        {
-            CancellationTokenSource cts = new CancellationTokenSource(20000);
-            while (true)
+            public static async Task EventuallyAsync(Func<Task> act)
             {
-                try
+                CancellationTokenSource cts = new CancellationTokenSource(20000);
+                while (true)
                 {
-                    await act();
-                    break;
-                }
-                catch (XunitException) when (!cts.Token.IsCancellationRequested)
-                {
-                    await Task.Delay(500);
+                    try
+                    {
+                        await act();
+                        break;
+                    }
+                    catch (XunitException) when (!cts.Token.IsCancellationRequested)
+                    {
+                        await Task.Delay(500);
+                    }
                 }
             }
         }

BTCPayServer.Tests/docker-compose.yml

@@ -2,7 +2,7 @@ version: "3"
 
 # Run `docker-compose up dev` for bootstrapping your development environment
 # Doing so will expose NBXplorer, Bitcoind RPC and postgres port to the host so that tests can Run,
-# The Visual Studio launch setting `Docker-Regtest` is configured to use this environment.
+# The Visual Studio launch setting `Docker-regtest` is configured to use this environment.
 services:
 
   tests:
@@ -69,7 +69,7 @@ services:
 
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.0.0.2
+    image: nicolasdorier/nbxplorer:2.0.0.8
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -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/BTCPayNetworkProvider.Bitcoinplus.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoinplus()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("XBC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Bitcoinplus",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://chainz.cryptoid.info/xbc/tx.dws?{0}" : "https://chainz.cryptoid.info/xbc/tx.dws?{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoinplus",
+                DefaultRateRules = new[] 
+                {
+                                "XBC_X = XBC_BTC * BTC_X",
+                                "XBC_BTC = cryptopia(XBC_BTC)"
+                },
+                CryptoImagePath = "imlegacy/bitcoinplus.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("65'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Bitcore.cs

@@ -24,7 +24,7 @@ namespace BTCPayServer
                 DefaultRateRules = new[]
                 {
                                 "BTX_X = BTX_BTC * BTC_X",
-                                "BTX_BTC = cryptopia(BTX_BTC)"
+                                "BTX_BTC = hitbtc(BTX_BTC)"
                 },
                 CryptoImagePath = "imlegacy/bitcore.svg",
                 LightningImagePath = "imlegacy/bitcore-lightning.svg",

BTCPayServer/BTCPayNetworkProvider.cs

@@ -52,10 +52,13 @@ namespace BTCPayServer
             InitBitcoinGold();
             InitMonacoin();
             InitDash();
-            InitPolis();
             InitFeathercoin();
             InitGroestlcoin();
             InitViacoin();
+
+            // Disabled because of https://twitter.com/Cryptopia_NZ/status/1085084168852291586
+            //InitPolis();
+            //InitBitcoinplus();
             //InitUfo();
         }
 

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-		<Version>1.0.3.34</Version>
+		<Version>1.0.3.62</Version>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
@@ -33,11 +33,10 @@
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.4" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.9" />
     <PackageReference Include="BuildBundlerMinifier" Version="2.7.385" />
     <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.5.3" />
-    <PackageReference Include="Hangfire" Version="1.6.20" />
-    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
+    <PackageReference Include="HtmlSanitizer" Version="4.0.199" />
     <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" />
@@ -46,10 +45,10 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="NBitcoin" Version="4.1.1.73" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.30" />	  
+    <PackageReference Include="NBitcoin" Version="4.1.1.78" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.31" />	  
     <PackageReference Include="DBreeze" Version="1.92.0" />
-    <PackageReference Include="NBXplorer.Client" Version="2.0.0.1" />
+    <PackageReference Include="NBXplorer.Client" Version="2.0.0.3" />
     <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" />
@@ -126,6 +125,7 @@
 	  <Folder Include="Build\" />
 	  <Folder Include="wwwroot\vendor\clipboard.js\" />
 	  <Folder Include="wwwroot\vendor\highlightjs\" />
+	  <Folder Include="wwwroot\vendor\summernote" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -139,7 +139,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

@@ -61,6 +61,12 @@ namespace BTCPayServer.Configuration
             set;
         } = new List<NBXplorerConnectionSetting>();
 
+        public bool DisableRegistration
+        {
+            get;
+            private set;
+        }
+
         public static string GetDebugLog(IConfiguration configuration)
         {
             return configuration.GetValue<string>("debuglog", null);
@@ -104,7 +110,7 @@ namespace BTCPayServer.Configuration
                         if (!LightningConnectionString.TryParse(lightning, true, out var connectionString, out var error))
                         {
                             throw new ConfigException($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
-                                $"If you have a lightning server use: 'type=clightning;server=/root/.lightning/lightning-rpc', " + Environment.NewLine +
+                                $"If you have a 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 +
@@ -112,7 +118,7 @@ namespace BTCPayServer.Configuration
                         }
                         if (connectionString.IsLegacy)
                         {
-                            Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning will work but use an deprecated format, please replace it by '{connectionString.ToString()}'");
+                            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);
                     }
@@ -138,15 +144,30 @@ namespace BTCPayServer.Configuration
                 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))
+                    var spark = conf.GetOrDefault<string>($"{net.CryptoCode}.external.spark", string.Empty);
+                    if (spark.Length != 0)
                     {
-                        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'");
+                        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 rtl = conf.GetOrDefault<string>($"{net.CryptoCode}.external.rtl", string.Empty);
+                    if (rtl.Length != 0)
+                    {
+                        if (!SparkConnectionString.TryParse(rtl, out var connectionString))
+                        {
+                            throw new ConfigException($"Invalid setting {net.CryptoCode}.external.rtl, " + Environment.NewLine +
+                                $"Valid example: 'server=https://btcpay.example.com/rtl/btc/;cookiefile=/etc/clightning_bitcoin_rtl/.cookie'");
+                        }
+                        ExternalServicesByCryptoCode.Add(net.CryptoCode, new ExternalRTL(connectionString));
                     }
-                    ExternalServicesByCryptoCode.Add(net.CryptoCode, new ExternalSpark(connectionString));
                 }
 
                 var charge = conf.GetOrDefault<string>($"{net.CryptoCode}.external.charge", string.Empty);
@@ -171,10 +192,11 @@ namespace BTCPayServer.Configuration
             var services = conf.GetOrDefault<string>("externalservices", null);
             if (services != null)
             {
-                foreach (var service in services.Split(new[] { ';', ',' })
-                                                .Select(p => p.Split(':'))
-                                                .Where(p => p.Length == 2)
-                                                .Select(p => (Name: p[0], Link: p[1])))
+                foreach (var service in services.Split(new[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries)
+                                                .Select(p => (p, SeparatorIndex: p.IndexOf(':', StringComparison.OrdinalIgnoreCase)))
+                                                .Where(p => p.SeparatorIndex != -1)
+                                                .Select(p => (Name: p.p.Substring(0, p.SeparatorIndex), 
+                                                              Link: p.p.Substring(p.SeparatorIndex + 1))))
                 {
                     ExternalServices.AddOrReplace(service.Name, service.Link);
                 }
@@ -229,7 +251,7 @@ namespace BTCPayServer.Configuration
                 RootPath = "/" + RootPath;
             var old = conf.GetOrDefault<Uri>("internallightningnode", null);
             if (old != null)
-                throw new ConfigException($"internallightningnode should not be used anymore, use btclightning instead");
+                throw new ConfigException($"internallightningnode is deprecated and should not be used anymore, use btclightning instead");
 
             LogFile = GetDebugLog(conf);
             if (!string.IsNullOrEmpty(LogFile))
@@ -237,6 +259,8 @@ namespace BTCPayServer.Configuration
                 Logs.Configuration.LogInformation("LogFile: " + LogFile);
                 Logs.Configuration.LogInformation("Log Level: " + GetDebugLogLevel(conf));
             }
+
+            DisableRegistration = conf.GetOrDefault<bool>("disable-registration", true);
         }
 
         private SSHSettings ParseSSHConfiguration(IConfiguration conf)

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -43,6 +43,7 @@ namespace BTCPayServer.Configuration
             app.Option("--sshtrustedfingerprints", "SSH Host public key fingerprint or sha256 (default: empty, it will allow untrusted connections)", 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);
             foreach (var network in provider.GetAll())
             {
                 var crypto = network.CryptoCode.ToLowerInvariant();

BTCPayServer/Configuration/External/ExternalRTL.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Configuration.External
+{
+    public class ExternalRTL : ExternalService, IAccessKeyService
+    {
+        public SparkConnectionString ConnectionString { get; }
+
+        public ExternalRTL(SparkConnectionString connectionString)
+        {
+            if (connectionString == null)
+                throw new ArgumentNullException(nameof(connectionString));
+            ConnectionString = connectionString;
+        }
+
+        public async Task<string> ExtractAccessKey()
+        {
+            if (ConnectionString?.CookeFile == null)
+                throw new FormatException("Invalid connection string");
+            return await System.IO.File.ReadAllTextAsync(ConnectionString.CookeFile);
+        }
+    }
+}

BTCPayServer/Configuration/External/ExternalSpark.cs

@@ -5,7 +5,12 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Configuration.External
 {
-    public class ExternalSpark : ExternalService
+    public interface IAccessKeyService
+    {
+        SparkConnectionString ConnectionString { get; }
+        Task<string> ExtractAccessKey();
+    }
+    public class ExternalSpark : ExternalService, IAccessKeyService
     {
         public SparkConnectionString ConnectionString { get; }
 
@@ -15,5 +20,19 @@ namespace BTCPayServer.Configuration.External
                 throw new ArgumentNullException(nameof(connectionString));
             ConnectionString = connectionString;
         }
+
+        public async Task<string> ExtractAccessKey()
+        {
+            if (ConnectionString?.CookeFile == null)
+                throw new FormatException("Invalid connection string");
+            var cookie = (ConnectionString.CookeFile == "fake"
+                        ? "fake:fake:fake" // Hacks for testing
+                        : await System.IO.File.ReadAllTextAsync(ConnectionString.CookeFile)).Split(':');
+            if (cookie.Length >= 3)
+            {
+                return cookie[2];
+            }
+            throw new FormatException("Invalid cookiefile format");
+        }
     }
 }

BTCPayServer/Controllers/AccessTokenController.cs

@@ -2,6 +2,7 @@
 using BTCPayServer.Filters;
 using BTCPayServer.Models;
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin.DataEncoders;
 using NBitpayClient;
@@ -13,7 +14,7 @@ using System.Threading.Tasks;
 namespace BTCPayServer.Controllers
 {
     [Authorize(AuthenticationSchemes = Security.Policies.BitpayAuthentication)]
-    [BitpayAPIConstraint(true)]
+    [BitpayAPIConstraint()]
     public class AccessTokenController : Controller
     {
         TokenRepository _TokenRepository;

BTCPayServer/Controllers/AccountController.cs

@@ -28,10 +28,11 @@ namespace BTCPayServer.Controllers
     {
         private readonly UserManager<ApplicationUser> _userManager;
         private readonly SignInManager<ApplicationUser> _signInManager;
-        private readonly IEmailSender _emailSender;
+        private readonly EmailSenderFactory _EmailSenderFactory;
         StoreRepository storeRepository;
         RoleManager<IdentityRole> _RoleManager;
         SettingsRepository _SettingsRepository;
+        Configuration.BTCPayServerOptions _Options;
         ILogger _logger;
 
         public AccountController(
@@ -39,15 +40,17 @@ namespace BTCPayServer.Controllers
             RoleManager<IdentityRole> roleManager,
             StoreRepository storeRepository,
             SignInManager<ApplicationUser> signInManager,
-            IEmailSender emailSender,
-            SettingsRepository settingsRepository)
+            EmailSenderFactory emailSenderFactory,
+            SettingsRepository settingsRepository,
+            Configuration.BTCPayServerOptions options)
         {
             this.storeRepository = storeRepository;
             _userManager = userManager;
             _signInManager = signInManager;
-            _emailSender = emailSender;
+            _EmailSenderFactory = emailSenderFactory;
             _RoleManager = roleManager;
             _SettingsRepository = settingsRepository;
+            _Options = options;
             _logger = Logs.PayServer;
         }
 
@@ -271,12 +274,20 @@ namespace BTCPayServer.Controllers
                     {
                         await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
                         await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
+
+                        if(_Options.DisableRegistration)
+                        {
+                            // Once the admin user has been created lock subsequent user registrations (needs to be disabled for unit tests that require multiple users).
+                            policies.LockSubscription = true;
+                            await _SettingsRepository.UpdateSetting(policies);
+                        }
                     }
 
                     var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                     var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
                     RegisteredUserId = user.Id;
-                    await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
+
+                    _EmailSenderFactory.GetEmailSender().SendEmailConfirmation(model.Email, callbackUrl);
                     if (!policies.RequiresConfirmedEmail)
                     {
                         if(logon)
@@ -436,8 +447,9 @@ namespace BTCPayServer.Controllers
                 // visit https://go.microsoft.com/fwlink/?LinkID=532713
                 var code = await _userManager.GeneratePasswordResetTokenAsync(user);
                 var callbackUrl = Url.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);
-                await _emailSender.SendEmailAsync(model.Email, "Reset Password",
-                   $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
+                _EmailSenderFactory.GetEmailSender().SendEmail(model.Email, "Reset Password",
+                    $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
+                
                 return RedirectToAction(nameof(ForgotPasswordConfirmation));
             }
 

BTCPayServer/Controllers/AppsController.Crowdfund.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Threading.Tasks;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Services.Apps;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class AppsController
+    {
+        public class AppUpdated
+        {
+            public string AppId { get; set; }
+            public object Settings { get; set; }
+            public string StoreId { get; set; }
+            public override string ToString()
+            {
+                return String.Empty;
+            }
+        }
+        
+        
+        [HttpGet]
+        [Route("{appId}/settings/crowdfund")]
+        public async Task<IActionResult> UpdateCrowdfund(string appId)
+        {
+            var app = await GetOwnedApp(appId, AppType.Crowdfund);
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<CrowdfundSettings>();
+            var vm = new UpdateCrowdfundViewModel()
+            {
+                Title = settings.Title,
+                Enabled = settings.Enabled,
+                EnforceTargetAmount = settings.EnforceTargetAmount,
+                StartDate = settings.StartDate,
+                TargetCurrency = settings.TargetCurrency,
+                Description = settings.Description,
+                MainImageUrl = settings.MainImageUrl,
+                EmbeddedCSS = settings.EmbeddedCSS,
+                EndDate = settings.EndDate,
+                TargetAmount = settings.TargetAmount,
+                CustomCSSLink = settings.CustomCSSLink,
+                NotificationUrl = settings.NotificationUrl,
+                Tagline = settings.Tagline,
+                PerksTemplate = settings.PerksTemplate,
+                DisqusEnabled = settings.DisqusEnabled,
+                SoundsEnabled = settings.SoundsEnabled,
+                DisqusShortname = settings.DisqusShortname,
+                AnimationsEnabled = settings.AnimationsEnabled,
+                ResetEveryAmount = settings.ResetEveryAmount,
+                ResetEvery = Enum.GetName(typeof(CrowdfundResetEvery), settings.ResetEvery),
+                UseAllStoreInvoices = app.TagAllInvoices,
+                AppId = appId,
+                SearchTerm = app.TagAllInvoices ? $"storeid:{app.StoreDataId}" : $"orderid:{AppService.GetCrowdfundOrderId(appId)}",
+                DisplayPerksRanking = settings.DisplayPerksRanking,
+                SortPerksByPopularity = settings.SortPerksByPopularity
+            };
+            return View(vm);
+        }
+        [HttpPost]
+        [Route("{appId}/settings/crowdfund")]
+        public async Task<IActionResult> UpdateCrowdfund(string appId, UpdateCrowdfundViewModel vm)
+        {
+            if (!string.IsNullOrEmpty( vm.TargetCurrency) && _currencies.GetCurrencyData(vm.TargetCurrency, false) == null)
+                ModelState.AddModelError(nameof(vm.TargetCurrency), "Invalid currency");
+          
+            try
+            {
+                _AppService.Parse(vm.PerksTemplate, vm.TargetCurrency).ToString();
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(vm.PerksTemplate), "Invalid template");
+            }
+
+            if (Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery) != CrowdfundResetEvery.Never && !vm.StartDate.HasValue)
+            {
+                ModelState.AddModelError(nameof(vm.StartDate), "A start date is needed when the goal resets every X amount of time.");
+            }
+
+            if (Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery) != CrowdfundResetEvery.Never && vm.ResetEveryAmount <= 0)
+            {
+                ModelState.AddModelError(nameof(vm.ResetEveryAmount), "You must reset the goal at a minimum of 1 ");
+            }
+
+            if (vm.DisplayPerksRanking && !vm.SortPerksByPopularity)
+            {
+                ModelState.AddModelError(nameof(vm.DisplayPerksRanking), "You must sort by popularity in order to display ranking.");
+            }
+            
+            if (!ModelState.IsValid)
+            {
+                return View(vm);
+            }
+            
+            
+            var app = await GetOwnedApp(appId, AppType.Crowdfund);
+            if (app == null)
+                return NotFound();
+
+            var newSettings = new CrowdfundSettings()
+            {
+                Title = vm.Title,
+                Enabled = vm.Enabled,
+                EnforceTargetAmount = vm.EnforceTargetAmount,
+                StartDate = vm.StartDate,
+                TargetCurrency = vm.TargetCurrency,
+                Description = _htmlSanitizer.Sanitize( vm.Description),
+                EndDate = vm.EndDate,
+                TargetAmount = vm.TargetAmount,
+                CustomCSSLink = vm.CustomCSSLink,
+                MainImageUrl = vm.MainImageUrl,
+                EmbeddedCSS = vm.EmbeddedCSS,
+                NotificationUrl = vm.NotificationUrl,
+                Tagline = vm.Tagline,
+                PerksTemplate = vm.PerksTemplate,
+                DisqusEnabled = vm.DisqusEnabled,
+                SoundsEnabled = vm.SoundsEnabled,
+                DisqusShortname = vm.DisqusShortname,
+                AnimationsEnabled = vm.AnimationsEnabled,
+                ResetEveryAmount = vm.ResetEveryAmount,
+                ResetEvery = Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery),
+                DisplayPerksRanking = vm.DisplayPerksRanking,
+                SortPerksByPopularity = vm.SortPerksByPopularity
+            };
+
+            app.TagAllInvoices = vm.UseAllStoreInvoices;
+            app.SetSettings(newSettings);
+            await UpdateAppSettings(app);
+
+            _EventAggregator.Publish(new AppUpdated()
+            {
+                AppId = appId,
+                StoreId = app.StoreDataId,
+                Settings = newSettings
+            });
+            StatusMessage = "App updated";
+            return RedirectToAction(nameof(UpdateCrowdfund), new {appId});
+        }
+    }
+}

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -1,5 +1,8 @@
-using System.Text;
+using System;
+using System.Linq;
+using System.Text;
 using System.Text.Encodings.Web;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Models.AppViewModels;
@@ -65,6 +68,9 @@ namespace BTCPayServer.Controllers
             public string CustomButtonText { get; set; } = CUSTOM_BUTTON_TEXT_DEF;
             public const string CUSTOM_TIP_TEXT_DEF = "Do you want to leave a tip?";
             public string CustomTipText { get; set; } = CUSTOM_TIP_TEXT_DEF;
+            public static readonly int[] CUSTOM_TIP_PERCENTAGES_DEF = new int[] { 15, 18, 20 };
+            public int[] CustomTipPercentages { get; set; } = CUSTOM_TIP_PERCENTAGES_DEF;
+
 
             public string CustomCSSLink { get; set; }
         }
@@ -79,6 +85,7 @@ namespace BTCPayServer.Controllers
             var settings = app.GetSettings<PointOfSaleSettings>();
             var vm = new UpdatePointOfSaleViewModel()
             {
+                Id = appId,
                 Title = settings.Title,
                 EnableShoppingCart = settings.EnableShoppingCart,
                 ShowCustomAmount = settings.ShowCustomAmount,
@@ -87,6 +94,7 @@ namespace BTCPayServer.Controllers
                 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
             };
             if (HttpContext?.Request != null)
@@ -108,7 +116,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\" />");
@@ -130,11 +138,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
             {
@@ -157,6 +165,7 @@ namespace BTCPayServer.Controllers
                 ButtonText = vm.ButtonText,
                 CustomButtonText = vm.CustomButtonText,
                 CustomTipText = vm.CustomTipText,
+                CustomTipPercentages = ListSplit(vm.CustomTipPercentages),
                 CustomCSSLink = vm.CustomCSSLink
             });
             await UpdateAppSettings(app);
@@ -171,8 +180,25 @@ 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();
             }
         }
+
+        private int[] ListSplit(string list, string separator = ",")
+        {
+            if (string.IsNullOrEmpty(list))
+            {
+                return Array.Empty<int>();
+            } 
+            else 
+            {
+                // Remove all characters except numeric and comma
+                Regex charsToDestroy = new Regex(@"[^\d|\" + separator + "]");
+                list = charsToDestroy.Replace(list, "");
+
+                return list.Split(separator, System.StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();
+            }
+        }
     }
 }

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;
@@ -24,19 +26,28 @@ namespace BTCPayServer.Controllers
         public AppsController(
             UserManager<ApplicationUser> userManager,
             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; }
@@ -44,7 +55,7 @@ namespace BTCPayServer.Controllers
 
         public async Task<IActionResult> ListApps()
         {
-            var apps = await GetAllApps();
+            var apps = await _AppService.GetAllApps(GetUserId());
             return View(new ListAppsViewModel()
             {
                 Apps = apps
@@ -58,7 +69,7 @@ namespace BTCPayServer.Controllers
             var appData = await GetOwnedApp(appId);
             if (appData == null)
                 return NotFound();
-            if (await DeleteApp(appData))
+            if (await _AppService.DeleteApp(appData))
                 StatusMessage = "App removed successfully";
             return RedirectToAction(nameof(ListApps));
         }
@@ -67,10 +78,15 @@ namespace BTCPayServer.Controllers
         [Route("create")]
         public async Task<IActionResult> CreateApp()
         {
-            var stores = await GetOwnedStores();
+            var stores = await _AppService.GetOwnedStores(GetUserId());
             if (stores.Length == 0)
             {
-                StatusMessage = "Error: You must have created at least one store";
+                StatusMessage = new StatusMessageModel()
+                {
+                    Html =
+                        $"Error: You must have created at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
+                    Severity = StatusMessageModel.StatusSeverity.Error
+                }.ToString();
                 return RedirectToAction(nameof(ListApps));
             }
             var vm = new CreateAppViewModel();
@@ -82,10 +98,15 @@ namespace BTCPayServer.Controllers
         [Route("create")]
         public async Task<IActionResult> CreateApp(CreateAppViewModel vm)
         {
-            var stores = await GetOwnedStores();
+            var stores = await _AppService.GetOwnedStores(GetUserId());
             if (stores.Length == 0)
             {
-                StatusMessage = "Error: You must own at least one store";
+                StatusMessage = new StatusMessageModel()
+                {
+                    Html =
+                        $"Error: You must have created at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
+                    Severity = StatusMessageModel.StatusSeverity.Error
+                }.ToString();
                 return RedirectToAction(nameof(ListApps));
             }
             var selectedStore = vm.SelectedStore;
@@ -117,9 +138,17 @@ namespace BTCPayServer.Controllers
             }
             StatusMessage = "App successfully created";
             CreatedAppId = id;
-            if (appType == AppType.PointOfSale)
-                return RedirectToAction(nameof(UpdatePointOfSale), new { appId = id });
-            return RedirectToAction(nameof(ListApps));
+
+            switch (appType)
+            {
+                case AppType.PointOfSale:
+                    return RedirectToAction(nameof(UpdatePointOfSale), new { appId = id });
+                case AppType.Crowdfund:
+                    return RedirectToAction(nameof(UpdateCrowdfund), new { appId = id });
+                default:
+                    return RedirectToAction(nameof(ListApps));
+            }
+                
         }
 
         [HttpGet]
@@ -139,53 +168,10 @@ namespace BTCPayServer.Controllers
 
         private Task<AppData> GetOwnedApp(string appId, AppType? type = null)
         {
-            return _AppsHelper.GetAppDataIfOwner(GetUserId(), appId, type);
-        }
-
-        private async Task<StoreData[]> GetOwnedStores()
-        {
-            var userId = GetUserId();
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                return await ctx.UserStore
-                    .Where(us => us.ApplicationUserId == userId && us.Role == StoreRoles.Owner)
-                    .Select(u => u.StoreData)
-                    .ToArrayAsync();
-            }
-        }
-
-        private 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;
-            }
-        }
-
-        private async Task<ListAppsViewModel.ListAppViewModel[]> GetAllApps()
-        {
-            var userId = GetUserId();
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                return await ctx.UserStore
-                    .Where(us => 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();
-            }
+            return _AppService.GetAppDataIfOwner(GetUserId(), appId, type);
         }
 
+        
         private string GetUserId()
         {
             return _UserManager.GetUserId(User);

BTCPayServer/Controllers/AppsPublicController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -7,14 +8,21 @@ using System.Security.Claims;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Filters;
+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 Microsoft.AspNetCore.Authorization;
+using Ganss.XSS;
 using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using NBitpayClient;
 using YamlDotNet.RepresentationModel;
 using static BTCPayServer.Controllers.AppsController;
 
@@ -22,26 +30,30 @@ namespace BTCPayServer.Controllers
 {
     public class AppsPublicController : Controller
     {
-        public AppsPublicController(AppsHelper appsHelper, InvoiceController invoiceController)
+        public AppsPublicController(AppService AppService, 
+            InvoiceController invoiceController,
+            UserManager<ApplicationUser> userManager)
         {
-            _AppsHelper = appsHelper;
+            _AppService = AppService;
             _InvoiceController = invoiceController;
+            _UserManager = userManager;
         }
 
-        private AppsHelper _AppsHelper;
+        private AppService _AppService;
         private InvoiceController _InvoiceController;
+        private readonly UserManager<ApplicationUser> _UserManager;
 
         [HttpGet]
         [Route("/apps/{appId}/pos")]
-        [XFrameOptionsAttribute(null)]
+        [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()
@@ -61,16 +73,138 @@ 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,
-                CustomCSSLink = settings.CustomCSSLink
+                CustomTipPercentages = settings.CustomTipPercentages,
+                CustomCSSLink = settings.CustomCSSLink,
+                AppId = appId
             });
         }
+        
+        
+        [HttpGet]
+        [Route("/apps/{appId}/crowdfund")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        public async Task<IActionResult> ViewCrowdfund(string appId, string statusMessage)
+        
+        {
+            var app = await _AppService.GetApp(appId, AppType.Crowdfund, true);
+            
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<CrowdfundSettings>();
+            
+            var isAdmin = await _AppService.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
+            
+            var hasEnoughSettingsToLoad = !string.IsNullOrEmpty(settings.TargetCurrency );
+            if (!hasEnoughSettingsToLoad)
+            {
+                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 _AppService.GetAppInfo(appId));
+            if(!isAdmin)
+                return NotFound();
+
+            return View(await _AppService.GetAppInfo(appId));
+        }
+
+        [HttpPost]
+        [Route("/apps/{appId}/crowdfund")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        [IgnoreAntiforgeryToken]
+        [EnableCors(CorsPolicies.All)]
+        public async Task<IActionResult> ContributeToCrowdfund(string appId, ContributeToCrowdfund request)
+        {
+            var app = await _AppService.GetApp(appId, AppType.Crowdfund, true);
+
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<CrowdfundSettings>();
+
+
+            var isAdmin = await _AppService.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
+
+            if (!settings.Enabled)
+            {
+                if (!isAdmin)
+                    return NotFound("Crowdfund is not currently active");
+            }
+
+            var info = (ViewCrowdfundViewModel)await _AppService.GetAppInfo(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)))
+            {
+                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 = _AppService.Parse(settings.PerksTemplate, settings.TargetCurrency);
+                choice = choices.FirstOrDefault(c => c.Id == request.ChoiceKey);
+                if (choice == null)
+                    return NotFound("Incorrect option provided");
+                title = choice.Title;
+                price = choice.Price.Value;
+                if (request.Amount > price)
+                    price = request.Amount;
+            }
+
+            if (!isAdmin && (settings.EnforceTargetAmount && info.TargetAmount.HasValue && price >
+                             (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 CreateInvoiceRequest()
+                {
+                    OrderId = AppService.GetCrowdfundOrderId(appId),
+                    Currency = settings.TargetCurrency,
+                    ItemCode = request.ChoiceKey ?? string.Empty,
+                    ItemDesc = title,
+                    BuyerEmail = request.Email,
+                    Price = price,
+                    NotificationURL = settings.NotificationUrl,
+                    FullNotifications = true,
+                    ExtendedNotifications = true,
+                    RedirectURL = request.RedirectUrl ?? Request.GetDisplayUrl()
+                }, store, HttpContext.Request.GetAbsoluteRoot(), new List<string> { AppService.GetAppInternalTag(appId) });
+                if (request.RedirectToCheckout)
+                {
+                    return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice",
+                        new {invoiceId = invoice.Data.Id});
+                }
+                else
+                {
+                    return Ok(invoice.Data.Id);
+                }
+            }
+            catch (BitpayHttpException e)
+            {
+                return BadRequest(e.Message);
+            }
+            
+        }
 
         [HttpPost]
         [Route("/apps/{appId}/pos")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
         [IgnoreAntiforgeryToken]
         [EnableCors(CorsPolicies.All)]
         public async Task<IActionResult> ViewPointOfSale(string appId,
@@ -79,9 +213,10 @@ namespace BTCPayServer.Controllers
                                                         string orderId,
                                                         string notificationUrl,
                                                         string redirectUrl,
-                                                        string choiceKey)
+                                                        string choiceKey,
+                                                        string posData = null)
         {
-            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 });
@@ -95,10 +230,11 @@ namespace BTCPayServer.Controllers
             }
             string title = null;
             var price = 0.0m;
+            ViewPointOfSaleViewModel.Item choice = null;
             if (!string.IsNullOrEmpty(choiceKey))
             {
-                var choices = _AppsHelper.Parse(settings.Template, settings.Currency);
-                var choice = choices.FirstOrDefault(c => c.Id == choiceKey);
+                var choices = _AppService.Parse(settings.Template, settings.Currency);
+                choice = choices.FirstOrDefault(c => c.Id == choiceKey);
                 if (choice == null)
                     return NotFound();
                 title = choice.Title;
@@ -113,136 +249,28 @@ 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 = choiceKey ?? string.Empty,
+                ItemCode = choice?.Id,
                 ItemDesc = title,
                 Currency = settings.Currency,
                 Price = price,
                 BuyerEmail = email,
                 OrderId = orderId,
                 NotificationURL = notificationUrl,
-                RedirectURL = redirectUrl,
-                FullNotifications = true
+                RedirectURL = redirectUrl  ?? Request.GetDisplayUrl(),
+                FullNotifications = true,
+                PosData = string.IsNullOrEmpty(posData) ? null : posData
             }, store, HttpContext.Request.GetAbsoluteRoot());
             return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice", new { invoiceId = invoice.Data.Id });
         }
-    }
-
-
-    public class AppsHelper
-    {
-        ApplicationDbContextFactory _ContextFactory;
-        CurrencyNameTable _Currencies;
-        public CurrencyNameTable Currencies => _Currencies;
-        public AppsHelper(ApplicationDbContextFactory contextFactory, CurrencyNameTable currencies)
+        
+        
+        private string GetUserId()
         {
-            _ContextFactory = contextFactory;
-            _Currencies = currencies;
-
-        }
-
-        public async Task<AppData> GetApp(string appId, AppType appType)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                return await ctx.Apps
-                                .Where(us => us.Id == appId &&
-                                             us.AppType == appType.ToString())
-                                .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 = c.GetDetailString("description"),
-                    Id = c.Key,
-                    Image = c.GetDetailString("image"),
-                    Title = 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;
-            }
+            return _UserManager.GetUserId(User);
         }
     }
 }

BTCPayServer/Controllers/InvoiceController.API.cs

@@ -12,7 +12,6 @@ using NBitpayClient;
 
 namespace BTCPayServer.Controllers
 {
-    [EnableCors("BitpayAPI")]
     [BitpayAPIConstraint]
     [Authorize(Policies.CanCreateInvoice.Key, AuthenticationSchemes = Policies.BitpayAuthentication)]
     public class InvoiceControllerAPI : Controller
@@ -33,8 +32,10 @@ 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)
         {
+            if (invoice == null)
+                throw new BitpayHttpException(400, "Invalid invoice");
             return await _InvoiceController.CreateInvoiceCore(invoice, HttpContext.GetStoreData(), HttpContext.Request.GetAbsoluteRoot());
         }
 
@@ -66,15 +67,15 @@ namespace BTCPayServer.Controllers
         {
             if (dateEnd != null)
                 dateEnd = dateEnd.Value + TimeSpan.FromDays(1); //Should include the end day
-            
+
             var query = new InvoiceQuery()
             {
                 Count = limit,
                 Skip = offset,
                 EndDate = dateEnd,
                 StartDate = dateStart,
-                OrderId = orderId,
-                ItemCode = itemCode,
+                OrderId =  orderId == null ? null : new[] { orderId },
+                ItemCode =  itemCode == null ? null : new[] { itemCode },
                 Status = status == null ? null : new[] { status },
                 StoreId = new[] { this.HttpContext.GetStoreData().Id }
             };

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -13,6 +13,7 @@ using BTCPayServer.Models;
 using BTCPayServer.Models.InvoicingModels;
 using BTCPayServer.Payments;
 using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.CoinSwitch;
 using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Security;
 using BTCPayServer.Services.Invoices;
@@ -20,6 +21,7 @@ using BTCPayServer.Services.Invoices.Export;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.EntityFrameworkCore.Internal;
 using NBitcoin;
 using NBitpayClient;
 using NBXplorer;
@@ -63,6 +65,7 @@ namespace BTCPayServer.Controllers
                 OrderId = invoice.OrderId,
                 BuyerInformation = invoice.BuyerInformation,
                 Fiat = _CurrencyNameTable.DisplayFormatCurrency(dto.Price, dto.Currency),
+                TaxIncluded = _CurrencyNameTable.DisplayFormatCurrency(invoice.ProductInformation.TaxIncluded, dto.Currency),
                 NotificationEmail = invoice.NotificationEmail,
                 NotificationUrl = invoice.NotificationURL,
                 RedirectUrl = invoice.RedirectURL,
@@ -79,9 +82,9 @@ namespace BTCPayServer.Controllers
                 var paymentMethodId = data.GetId();
                 var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
                 cryptoPayment.PaymentMethod = ToString(paymentMethodId);
-                cryptoPayment.Due = $"{accounting.Due} {paymentMethodId.CryptoCode}";
-                cryptoPayment.Paid = $"{accounting.CryptoPaid} {paymentMethodId.CryptoCode}";
-                cryptoPayment.Overpaid = $"{accounting.OverpaidHelper} {paymentMethodId.CryptoCode}";
+                cryptoPayment.Due = _CurrencyNameTable.DisplayFormatCurrency(accounting.Due.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
+                cryptoPayment.Paid = _CurrencyNameTable.DisplayFormatCurrency(accounting.CryptoPaid.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
+                cryptoPayment.Overpaid = _CurrencyNameTable.DisplayFormatCurrency(accounting.OverpaidHelper.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
 
                 var onchainMethod = data.GetPaymentMethodDetails() as Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod;
                 if (onchainMethod != null)
@@ -187,7 +190,7 @@ namespace BTCPayServer.Controllers
             id = invoiceId;
             ////
 
-            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
             if (model == null)
                 return NotFound();
 
@@ -210,31 +213,29 @@ namespace BTCPayServer.Controllers
             return View(nameof(Checkout), model);
         }
 
-        private async Task<PaymentModel> GetInvoiceModel(string invoiceId, string paymentMethodIdStr)
+        private async Task<PaymentModel> GetInvoiceModel(string invoiceId, PaymentMethodId paymentMethodId)
         {
             var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
             if (invoice == null)
                 return null;
             var store = await _StoreRepository.FindStore(invoice.StoreId);
-            bool isDefaultCrypto = false;
-            if (paymentMethodIdStr == null)
+            bool isDefaultPaymentId = false;
+            if (paymentMethodId == null)
             {
-                paymentMethodIdStr = store.GetDefaultCrypto(_NetworkProvider);
-                isDefaultCrypto = true;
+                paymentMethodId = store.GetDefaultPaymentId(_NetworkProvider);
+                isDefaultPaymentId = true;
             }
-            var paymentMethodId = PaymentMethodId.Parse(paymentMethodIdStr);
             var network = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode);
-            if (network == null && isDefaultCrypto)
+            if (network == null && isDefaultPaymentId)
             {
                 network = _NetworkProvider.GetAll().FirstOrDefault();
                 paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
-                paymentMethodIdStr = paymentMethodId.ToString();
             }
             if (invoice == null || network == null)
                 return null;
             if (!invoice.Support(paymentMethodId))
             {
-                if (!isDefaultCrypto)
+                if (!isDefaultPaymentId)
                     return null;
                 var paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider)
                                                .Where(c => paymentMethodId.CryptoCode == c.GetId().CryptoCode)
@@ -243,7 +244,6 @@ namespace BTCPayServer.Controllers
                     paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider).First();
                 network = paymentMethodTemp.Network;
                 paymentMethodId = paymentMethodTemp.GetId();
-                paymentMethodIdStr = paymentMethodId.ToString();
             }
 
             var paymentMethod = invoice.GetPaymentMethod(paymentMethodId, _NetworkProvider);
@@ -258,6 +258,11 @@ namespace BTCPayServer.Controllers
                                            storeBlob.ChangellySettings.IsConfigured())
                 ? storeBlob.ChangellySettings
                 : null;
+            
+            CoinSwitchSettings coinswitch = (storeBlob.CoinSwitchSettings != null && storeBlob.CoinSwitchSettings.Enabled &&
+                                           storeBlob.CoinSwitchSettings.IsConfigured())
+                ? storeBlob.CoinSwitchSettings
+                : null;
 
 
             var changellyAmountDue = changelly != null
@@ -272,7 +277,6 @@ namespace BTCPayServer.Controllers
                 PaymentMethodName = GetDisplayName(paymentMethodId, network),
                 CryptoImage = GetImage(paymentMethodId, network),
                 IsLightning = paymentMethodId.PaymentType == PaymentTypes.LightningLike,
-                ServerUrl = HttpContext.Request.GetAbsoluteRoot(),
                 OrderId = invoice.OrderId,
                 InvoiceId = invoice.Id,
                 DefaultLang = storeBlob.DefaultLang ?? "en",
@@ -304,11 +308,14 @@ namespace BTCPayServer.Controllers
 #pragma warning disable CS0618 // Type or member is obsolete
                 Status = invoice.StatusString,
 #pragma warning restore CS0618 // Type or member is obsolete
-                NetworkFee = paymentMethodDetails.GetTxFee(),
+                NetworkFee = paymentMethodDetails.GetNextNetworkFee(),
                 IsMultiCurrency = invoice.GetPayments().Select(p => p.GetPaymentMethodId()).Concat(new[] { paymentMethod.GetId() }).Distinct().Count() > 1,
                 ChangellyEnabled = changelly != null,
                 ChangellyMerchantId = changelly?.ChangellyMerchantId,
                 ChangellyAmountDue = changellyAmountDue,
+                CoinSwitchEnabled = coinswitch != null,
+                CoinSwitchMerchantId = coinswitch?.MerchantId,
+                CoinSwitchMode = coinswitch?.Mode,
                 StoreId = store.Id,
                 AvailableCryptos = invoice.GetPaymentMethods(_NetworkProvider)
                                           .Where(i => i.Network != null)
@@ -360,9 +367,12 @@ namespace BTCPayServer.Controllers
         [HttpGet]
         [Route("i/{invoiceId}/status")]
         [Route("i/{invoiceId}/{paymentMethodId}/status")]
+        [Route("invoice/{invoiceId}/status")]
+        [Route("invoice/{invoiceId}/{paymentMethodId}/status")]
+        [Route("invoice/status")]
         public async Task<IActionResult> GetStatus(string invoiceId, string paymentMethodId = null)
         {
-            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
             if (model == null)
                 return NotFound();
             return Json(model);
@@ -370,6 +380,10 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [Route("i/{invoiceId}/status/ws")]
+        [Route("i/{invoiceId}/{paymentMethodId}/status/ws")]
+        [Route("invoice/{invoiceId}/status/ws")]
+        [Route("invoice/{invoiceId}/{paymentMethodId}/status")]
+        [Route("invoice/status/ws")]
         public async Task<IActionResult> GetStatusWebSocket(string invoiceId)
         {
             if (!HttpContext.WebSockets.IsWebSocketRequest)
@@ -415,6 +429,7 @@ namespace BTCPayServer.Controllers
 
         [HttpPost]
         [Route("i/{invoiceId}/UpdateCustomer")]
+        [Route("invoice/UpdateCustomer")]
         public async Task<IActionResult> UpdateCustomer(string invoiceId, [FromBody]UpdateCustomerModel data)
         {
             if (!ModelState.IsValid)
@@ -438,8 +453,12 @@ namespace BTCPayServer.Controllers
                 Count = count,
                 StatusMessage = StatusMessage
             };
-
-            var list = await ListInvoicesProcess(searchTerm, skip, count);
+            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm);
+            var counting = _InvoiceRepository.GetInvoicesTotal(invoiceQuery);
+            invoiceQuery.Count = count;
+            invoiceQuery.Skip = skip;
+            var list = await _InvoiceRepository.GetInvoices(invoiceQuery);
+            
             foreach (var invoice in list)
             {
                 var state = invoice.GetInvoiceState();
@@ -451,32 +470,32 @@ namespace BTCPayServer.Controllers
                     InvoiceId = invoice.Id,
                     OrderId = invoice.OrderId ?? string.Empty,
                     RedirectUrl = invoice.RedirectURL ?? string.Empty,
-                    AmountCurrency = $"{invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture)} {invoice.ProductInformation.Currency}",
+                    AmountCurrency = _CurrencyNameTable.DisplayFormatCurrency(invoice.ProductInformation.Price, invoice.ProductInformation.Currency),
                     CanMarkInvalid = state.CanMarkInvalid(),
                     CanMarkComplete = state.CanMarkComplete()
                 });
             }
+            model.Total = await counting;
             return View(model);
         }
 
-        private async Task<InvoiceEntity[]> ListInvoicesProcess(string searchTerm = null, int skip = 0, int count = 50)
+        private InvoiceQuery GetInvoiceQuery(string searchTerm = null)
         {
             var filterString = new SearchString(searchTerm);
-            var list = await _InvoiceRepository.GetInvoices(new InvoiceQuery()
+            var invoiceQuery = new InvoiceQuery()
             {
                 TextSearch = filterString.TextSearch,
-                Count = count,
-                Skip = skip,
                 UserId = GetUserId(),
                 Unusual = !filterString.Filters.ContainsKey("unusual") ? null
                           : !bool.TryParse(filterString.Filters["unusual"].First(), out var r) ? (bool?)null
                           : r,
                 Status = filterString.Filters.ContainsKey("status") ? filterString.Filters["status"].ToArray() : null,
                 ExceptionStatus = filterString.Filters.ContainsKey("exceptionstatus") ? filterString.Filters["exceptionstatus"].ToArray() : null,
-                StoreId = filterString.Filters.ContainsKey("storeid") ? filterString.Filters["storeid"].ToArray() : null
-            });
-
-            return list;
+                StoreId = filterString.Filters.ContainsKey("storeid") ? filterString.Filters["storeid"].ToArray() : null,
+                ItemCode = filterString.Filters.ContainsKey("itemcode") ? filterString.Filters["itemcode"].ToArray() : null,
+                OrderId = filterString.Filters.ContainsKey("orderid") ? filterString.Filters["orderid"].ToArray() : null
+            };
+            return invoiceQuery;
         }
 
         [HttpGet]
@@ -484,9 +503,12 @@ namespace BTCPayServer.Controllers
         [BitpayAPIConstraint(false)]
         public async Task<IActionResult> Export(string format, string searchTerm = null)
         {
-            var model = new InvoiceExport(_NetworkProvider);
+            var model = new InvoiceExport(_NetworkProvider, _CurrencyNameTable);
 
-            var invoices = await ListInvoicesProcess(searchTerm, 0, int.MaxValue);
+            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm);
+            invoiceQuery.Count = int.MaxValue;
+            invoiceQuery.Skip = 0;
+            var invoices = await _InvoiceRepository.GetInvoices(invoiceQuery);
             var res = model.Process(invoices, format);
 
             var cd = new ContentDisposition
@@ -556,7 +578,7 @@ namespace BTCPayServer.Controllers
 
             try
             {
-                var result = await CreateInvoiceCore(new Invoice()
+                var result = await CreateInvoiceCore(new CreateInvoiceRequest()
                 {
                     Price = model.Amount.Value,
                     Currency = model.Currency,
@@ -638,13 +660,13 @@ namespace BTCPayServer.Controllers
             if (newState == "invalid")
             {
                 await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
-                _EventAggregator.Publish(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1008, "invoice_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, "invoice_markedComplete"));
+                _EventAggregator.Publish(new InvoiceEvent(invoice, 2008, InvoiceEvent.MarkedCompleted));
                 StatusMessage = "Invoice marked complete";
             }
             return RedirectToAction(nameof(ListInvoices));
@@ -664,9 +686,9 @@ namespace BTCPayServer.Controllers
 
         public class PosDataParser
         {
-            public static Dictionary<string, string> ParsePosData(string posData)
+            public static Dictionary<string, object> ParsePosData(string posData)
             {
-                var result = new Dictionary<string,string>();
+                var result = new Dictionary<string,object>();
                 if (string.IsNullOrEmpty(posData))
                 {
                     return result;
@@ -674,7 +696,6 @@ namespace BTCPayServer.Controllers
             
                 try
                 {
-                
                     var jObject =JObject.Parse(posData);
                     foreach (var item in jObject)
                     {
@@ -682,7 +703,14 @@ namespace BTCPayServer.Controllers
                         switch (item.Value.Type)
                         {
                             case JTokenType.Array:
-                                result.Add(item.Key, string.Join(',', item.Value.AsEnumerable()));
+                                var items = item.Value.AsEnumerable().ToList();
+                                for (var i = 0; i < items.Count(); i++)
+                                {
+                                    result.Add($"{item.Key}[{i}]", ParsePosData(items[i].ToString()));
+                                }
+                                break;
+                            case JTokenType.Object:
+                                result.Add(item.Key, ParsePosData(item.Value.ToString()));
                                 break;
                             default:
                                 result.Add(item.Key, item.Value.ToString());

BTCPayServer/Controllers/InvoiceController.cs

@@ -5,11 +5,13 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
+using BTCPayServer.Events;
 using BTCPayServer.Logging;
 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;
@@ -60,7 +62,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)
         {
             if (!store.HasClaim(Policies.CanCreateInvoice.Key))
                 throw new UnauthorizedAccessException();
@@ -71,10 +73,8 @@ namespace BTCPayServer.Controllers
                 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 +82,17 @@ 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)
@@ -94,7 +101,22 @@ namespace BTCPayServer.Controllers
                     throw new BitpayHttpException(400, "Invalid email");
                 entity.RefundMail = entity.BuyerInformation.BuyerEmail;
             }
-            entity.ProductInformation = Map<Invoice, ProductInformation>(invoice);
+
+            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(taxIncluded, currencyInfo.CurrencyDecimalDigits);
+            }
+            invoice.Price = Math.Max(0.0m, invoice.Price);
+            invoice.TaxIncluded = Math.Max(0.0m, taxIncluded);
+            invoice.TaxIncluded = Math.Min(taxIncluded, invoice.Price);
+
+            entity.ProductInformation = Map<CreateInvoiceRequest, ProductInformation>(invoice);
+
+
             entity.RedirectURL = invoice.RedirectURL ?? store.StoreWebsite;
             if (!Uri.IsWellFormedUriString(entity.RedirectURL, UriKind.Absolute))
                 entity.RedirectURL = null;
@@ -105,6 +127,17 @@ namespace BTCPayServer.Controllers
             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))
@@ -146,7 +179,7 @@ namespace BTCPayServer.Controllers
             if (supported.Count == 0)
             {
                 StringBuilder errors = new StringBuilder();
-                errors.AppendLine("No payment method available for this store");
+                errors.AppendLine("Warning: No wallet has been linked to your BTCPay Store. See the following link for more information on how to connect your store and wallet. (https://docs.btcpayserver.org/btcpay-basics/gettingstarted#connecting-btcpay-store-to-your-wallet)");
                 foreach (var error in logs.ToList())
                 {
                     errors.AppendLine(error.ToString());
@@ -157,9 +190,15 @@ namespace BTCPayServer.Controllers
             entity.SetSupportedPaymentMethods(supported);
             entity.SetPaymentMethods(paymentMethods);
             entity.PosData = invoice.PosData;
+
+            foreach (var app in await getAppsTaggingStore)
+            {
+                entity.InternalTags.Add(AppService.GetAppInternalTag(app.Id));
+            }
+
             entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, logs, _NetworkProvider);
             await fetchingAll;
-            _EventAggregator.Publish(new Events.InvoiceEvent(entity.EntityToDTO(_NetworkProvider), 1001, "invoice_created"));
+            _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, InvoiceEvent.Created));
             var resp = entity.EntityToDTO(_NetworkProvider);
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }
@@ -200,8 +239,6 @@ namespace BTCPayServer.Controllers
                 paymentMethod.SetId(supportedPaymentMethod.PaymentId);
                 paymentMethod.Rate = rate.BidAsk.Bid;
                 var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network, preparePayment);
-                if (storeBlob.NetworkFeeDisabled)
-                    paymentDetails.SetNoTxFee();
                 paymentMethod.SetPaymentMethodDetails(paymentDetails);
 
                 Func<Money, Money, bool> compare = null;
@@ -241,7 +278,7 @@ namespace BTCPayServer.Controllers
 #pragma warning disable CS0618
                 if (paymentMethod.GetId().IsBTCOnChain)
                 {
-                    entity.TxFee = paymentMethod.TxFee;
+                    entity.TxFee = paymentMethod.NextNetworkFee;
                     entity.Rate = paymentMethod.Rate;
                     entity.DepositAddress = paymentMethod.DepositAddress;
                 }

BTCPayServer/Controllers/ManageController.cs

@@ -31,7 +31,7 @@ namespace BTCPayServer.Controllers
     {
         private readonly UserManager<ApplicationUser> _userManager;
         private readonly SignInManager<ApplicationUser> _signInManager;
-        private readonly IEmailSender _emailSender;
+        private readonly EmailSenderFactory _EmailSenderFactory;
         private readonly ILogger _logger;
         private readonly UrlEncoder _urlEncoder;
         TokenRepository _TokenRepository;
@@ -44,7 +44,7 @@ namespace BTCPayServer.Controllers
         public ManageController(
           UserManager<ApplicationUser> userManager,
           SignInManager<ApplicationUser> signInManager,
-          IEmailSender emailSender,
+          EmailSenderFactory emailSenderFactory,
           ILogger<ManageController> logger,
           UrlEncoder urlEncoder,
           TokenRepository tokenRepository,
@@ -54,7 +54,7 @@ namespace BTCPayServer.Controllers
         {
             _userManager = userManager;
             _signInManager = signInManager;
-            _emailSender = emailSender;
+            _EmailSenderFactory = emailSenderFactory;
             _logger = logger;
             _urlEncoder = urlEncoder;
             _TokenRepository = tokenRepository;
@@ -156,8 +156,7 @@ namespace BTCPayServer.Controllers
             var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
             var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
             var email = user.Email;
-            await _emailSender.SendEmailConfirmationAsync(email, callbackUrl);
-
+            _EmailSenderFactory.GetEmailSender().SendEmailConfirmation(email, callbackUrl);
             StatusMessage = "Verification email sent. Please check your email.";
             return RedirectToAction(nameof(Index));
         }

BTCPayServer/Controllers/PublicController.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
+using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Services.Stores;
 using Microsoft.AspNetCore.Cors;
@@ -45,7 +46,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,

BTCPayServer/Controllers/PublicLightningNodeInfoController.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Filters;
+using BTCPayServer.Lightning;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Services.Stores;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+
+namespace BTCPayServer.Controllers
+{
+    
+    [Route("embed/{storeId}/{cryptoCode}/ln")]
+    [AllowAnonymous]
+    public class PublicLightningNodeInfoController : Controller
+    {
+        private readonly BTCPayNetworkProvider _BtcPayNetworkProvider;
+        private readonly LightningLikePaymentHandler _LightningLikePaymentHandler;
+        private readonly StoreRepository _StoreRepository;
+
+        public PublicLightningNodeInfoController(BTCPayNetworkProvider btcPayNetworkProvider, 
+            LightningLikePaymentHandler lightningLikePaymentHandler, StoreRepository storeRepository)
+        {
+            _BtcPayNetworkProvider = btcPayNetworkProvider;
+            _LightningLikePaymentHandler = lightningLikePaymentHandler;
+            _StoreRepository = storeRepository;
+        }
+        
+        [HttpGet]
+        [XFrameOptions(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        public async Task<IActionResult> ShowLightningNodeInfo(string storeId, string cryptoCode)
+        {
+            var store = await _StoreRepository.FindStore(storeId);
+            if (store == null)
+                return NotFound();
+
+            try
+            {
+                var paymentMethodDetails = GetExistingLightningSupportedPaymentMethod(cryptoCode, store);
+                var network = _BtcPayNetworkProvider.GetNetwork(cryptoCode);
+                var nodeInfo =
+                    await _LightningLikePaymentHandler.GetNodeInfo(paymentMethodDetails,
+                        network);
+
+                return View(new ShowLightningNodeInfoViewModel()
+                {
+                    Available = true,
+                    NodeInfo = nodeInfo.ToString(),
+                    CryptoCode = cryptoCode,
+                    CryptoImage = GetImage(paymentMethodDetails.PaymentId, network)
+                });
+            }
+            catch (Exception)
+            {
+                return View(new ShowLightningNodeInfoViewModel() {Available = false, CryptoCode = cryptoCode});
+            }
+        }
+        
+        private LightningSupportedPaymentMethod GetExistingLightningSupportedPaymentMethod(string cryptoCode, StoreData store)
+        {
+            var id = new PaymentMethodId(cryptoCode, PaymentTypes.LightningLike);
+            var existing = store.GetSupportedPaymentMethods(_BtcPayNetworkProvider)
+                .OfType<LightningSupportedPaymentMethod>()
+                .FirstOrDefault(d => d.PaymentId == id);
+            return existing;
+        }
+
+
+        private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
+        {
+            var res = paymentMethodId.PaymentType == PaymentTypes.BTCLike
+                ? Url.Content(network.CryptoImagePath)
+                : Url.Content(network.LightningImagePath);
+            return "/" + res;
+        }
+    }
+
+    public class ShowLightningNodeInfoViewModel
+    {
+        public string NodeInfo { get; set; }
+        public bool Available { get; set; }
+        public string CryptoCode { get; set; }
+        public string CryptoImage { get; set; }
+    }
+}

BTCPayServer/Controllers/RateController.cs

@@ -12,11 +12,13 @@ using BTCPayServer.Rating;
 using Newtonsoft.Json;
 using Microsoft.AspNetCore.Authorization;
 using BTCPayServer.Authentication;
+using Microsoft.AspNetCore.Cors;
 
 namespace BTCPayServer.Controllers
 {
     [Authorize(AuthenticationSchemes = Security.Policies.BitpayAuthentication)]
     [AllowAnonymous]
+    [EnableCors(CorsPolicies.All)]
     public class RateController : Controller
     {
         RateFetcher _RateProviderFactory;
@@ -139,9 +141,9 @@ namespace BTCPayServer.Controllers
             {
                 var supportedMethods = store.GetSupportedPaymentMethods(_NetworkProvider);
                 var currencyCodes = supportedMethods.Select(method => method.PaymentId.CryptoCode).Distinct();
-                var defaultCrypto = store.GetDefaultCrypto(_NetworkProvider);
+                var defaultPaymentId = store.GetDefaultPaymentId(_NetworkProvider);
 
-                currencyPairs = BuildCurrencyPairs(currencyCodes, defaultCrypto);
+                currencyPairs = BuildCurrencyPairs(currencyCodes, defaultPaymentId.CryptoCode);
 
                 if (string.IsNullOrEmpty(currencyPairs))
                 {

BTCPayServer/Controllers/ServerController.cs

@@ -27,6 +27,7 @@ using Renci.SshNet;
 using BTCPayServer.Logging;
 using BTCPayServer.Lightning;
 using BTCPayServer.Configuration.External;
+using System.Runtime.CompilerServices;
 
 namespace BTCPayServer.Controllers
 {
@@ -170,7 +171,7 @@ namespace BTCPayServer.Controllers
                 vm.DNSDomain = null;
             return View(vm);
         }
-        
+
         [Route("server/maintenance")]
         [HttpPost]
         public async Task<IActionResult> Maintenance(MaintenanceViewModel vm, string command)
@@ -208,8 +209,8 @@ namespace BTCPayServer.Controllers
                     {
                         builder.Scheme = this.Request.Scheme;
                         builder.Host = vm.DNSDomain;
-                        var addresses1 = Dns.GetHostAddressesAsync(this.Request.Host.Host);
-                        var addresses2 = Dns.GetHostAddressesAsync(vm.DNSDomain);
+                        var addresses1 = GetAddressAsync(this.Request.Host.Host);
+                        var addresses2 = GetAddressAsync(vm.DNSDomain);
                         await Task.WhenAll(addresses1, addresses2);
 
                         var addressesSet = addresses1.GetAwaiter().GetResult().Select(c => c.ToString()).ToHashSet();
@@ -253,6 +254,13 @@ namespace BTCPayServer.Controllers
             return RedirectToAction(nameof(Maintenance));
         }
 
+        private Task<IPAddress[]> GetAddressAsync(string domainOrIP)
+        {
+            if (IPAddress.TryParse(domainOrIP, out var ip))
+                return Task.FromResult(new[] { ip });
+            return Dns.GetHostAddressesAsync(domainOrIP);
+        }
+
         public static string RunId = Encoders.Hex.EncodeData(NBitcoin.RandomUtils.GetBytes(32));
         [HttpGet]
         [Route("runid")]
@@ -345,22 +353,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);
         }
 
@@ -371,12 +384,29 @@ namespace BTCPayServer.Controllers
             var user = userId == null ? null : await _UserManager.FindByIdAsync(userId);
             if (user == null)
                 return NotFound();
-            return View("Confirm", new ConfirmModel()
+
+            var admins = await _UserManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+            if (admins.Count == 1)
             {
-                Title = "Delete user " + user.Email,
-                Description = "This user will be permanently deleted",
-                Action = "Delete"
-            });
+                // return
+                return View("Confirm", new ConfirmModel("Unable to Delete Last Admin",
+                    "This is the last Admin, so it can't be removed"));
+            }
+
+
+            var roles = await _UserManager.GetRolesAsync(user);
+            if (IsAdmin(roles))
+            {
+                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")]
@@ -445,7 +475,17 @@ namespace BTCPayServer.Controllers
                     {
                         Crypto = cryptoCode,
                         Type = "Spark server",
-                        Action = nameof(SparkServices),
+                        Action = nameof(SparkService),
+                        Index = i++,
+                    });
+                }
+                foreach (var rtlService in _Options.ExternalServicesByCryptoCode.GetServices<ExternalRTL>(cryptoCode))
+                {
+                    result.LNDServices.Add(new ServicesViewModel.LNDServiceViewModel()
+                    {
+                        Crypto = cryptoCode,
+                        Type = "Ride the Lightning server (RTL)",
+                        Action = nameof(RTLService),
                         Index = i++,
                     });
                 }
@@ -460,15 +500,15 @@ namespace BTCPayServer.Controllers
                     });
                 }
             }
-            foreach(var externalService in _Options.ExternalServices)
+            foreach (var externalService in _Options.ExternalServices)
             {
                 result.ExternalServices.Add(new ServicesViewModel.ExternalService()
                 {
                     Name = externalService.Key,
-                    Link = this.Request.GetRelativePath(externalService.Value)
+                    Link = this.Request.GetRelativePathOrAbsolute(externalService.Value)
                 });
             }
-            if(_Options.SSHSettings != null)
+            if (_Options.SSHSettings != null)
             {
                 result.ExternalServices.Add(new ServicesViewModel.ExternalService()
                 {
@@ -519,37 +559,41 @@ namespace BTCPayServer.Controllers
         }
 
         [Route("server/services/spark/{cryptoCode}/{index}")]
-        public async Task<IActionResult> SparkServices(string cryptoCode, int index, bool showQR = false)
+        public async Task<IActionResult> SparkService(string cryptoCode, int index, bool showQR = false)
+        {
+            return await LightningWalletServicesCore<ExternalSpark>(cryptoCode, showQR, "Spark Wallet");
+        }
+        [Route("server/services/rtl/{cryptoCode}/{index}")]
+        public async Task<IActionResult> RTLService(string cryptoCode, int index, bool showQR = false)
+        {
+            return await LightningWalletServicesCore<ExternalRTL>(cryptoCode, showQR, "Ride the Lightning Wallet");
+        }
+        private async Task<IActionResult> LightningWalletServicesCore<T>(string cryptoCode, bool showQR, string walletName) where T : ExternalService, IAccessKeyService
         {
             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)
+            var external = _Options.ExternalServicesByCryptoCode.GetServices<T>(cryptoCode).Where(c => c?.ConnectionString?.Server != null).FirstOrDefault();
+            if (external == null)
             {
                 return NotFound();
             }
 
-            SparkServicesViewModel vm = new SparkServicesViewModel();
+            LightningWalletServices vm = new LightningWalletServices();
             vm.ShowQR = showQR;
+            vm.WalletName = walletName;
             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]}";
-                }
+                vm.ServiceLink = $"{external.ConnectionString.Server.AbsoluteUri}?access-key={await external.ExtractAccessKey()}";
             }
-            catch(Exception ex)
+            catch (Exception ex)
             {
                 StatusMessage = $"Error: {ex.Message}";
                 return RedirectToAction(nameof(Services));
             }
-            return View(vm);
+            return View("LightningWalletServices", vm);
         }
 
         [Route("server/services/lnd/{cryptoCode}/{index}")]
@@ -571,7 +615,7 @@ namespace BTCPayServer.Controllers
                 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 (external.ConnectionType == LightningConnectionType.LndREST)
             {
                 model.Uri = external.BaseUri.AbsoluteUri;
                 model.ConnectionType = "REST";
@@ -785,7 +829,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.BTCLike.cs

@@ -46,7 +46,7 @@ namespace BTCPayServer.Controllers
             string storeId,
             string cryptoCode,
             string command,
-            int account = 0)
+            string keyPath = "")
         {
             if (!HttpContext.WebSockets.IsWebSocketRequest)
                 return NotFound();
@@ -67,7 +67,10 @@ namespace BTCPayServer.Controllers
                     }
                     if (command == "getxpub")
                     {
-                        var getxpubResult = await hw.GetExtPubKey(network, account, normalOperationTimeout.Token);
+                        var k = KeyPath.Parse(keyPath);
+                        if (k.Indexes.Length == 0)
+                            throw new FormatException("Invalid key path");
+                        var getxpubResult = await hw.GetExtPubKey(network, k, normalOperationTimeout.Token);
                         result = getxpubResult;
                     }
                 }
@@ -171,7 +174,8 @@ namespace BTCPayServer.Controllers
                     if (strategy != null)
                         await wallet.TrackAsync(strategy.DerivationStrategyBase);
                     store.SetSupportedPaymentMethod(paymentMethodId, strategy);
-                    storeBlob.SetExcluded(paymentMethodId, willBeExcluded);
+                    storeBlob.SetExcluded(paymentMethodId, willBeExcluded);                    
+                    storeBlob.SetWalletKeyPathRoot(paymentMethodId, vm.KeyPath == null ? null : KeyPath.Parse(vm.KeyPath));
                     store.SetStoreBlob(storeBlob);
                 }
                 catch

BTCPayServer/Controllers/StoresController.CoinSwitch.cs

@@ -0,0 +1,72 @@
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.CoinSwitch;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class StoresController
+    {
+        [HttpGet]
+        [Route("{storeId}/coinswitch")]
+        public IActionResult UpdateCoinSwitchSettings(string storeId)
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            UpdateCoinSwitchSettingsViewModel vm = new UpdateCoinSwitchSettingsViewModel();
+            SetExistingValues(store, vm);
+            return View(vm);
+        }
+
+        private void SetExistingValues(StoreData store, UpdateCoinSwitchSettingsViewModel vm)
+        {
+
+            var existing = store.GetStoreBlob().CoinSwitchSettings;
+            if (existing == null) return;
+            vm.MerchantId = existing.MerchantId;
+            vm.Enabled = existing.Enabled;
+            vm.Mode = existing.Mode;
+        }
+
+        [HttpPost]
+        [Route("{storeId}/coinswitch")]
+        public async Task<IActionResult> UpdateCoinSwitchSettings(string storeId, UpdateCoinSwitchSettingsViewModel vm,
+            string command)
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            if (vm.Enabled)
+            {
+                if (!ModelState.IsValid)
+                {
+                    return View(vm);
+                }
+            }
+
+            var coinSwitchSettings = new CoinSwitchSettings()
+            {
+                MerchantId =  vm.MerchantId,
+                Enabled = vm.Enabled,
+                Mode = vm.Mode
+            };
+            
+            switch (command)
+            {
+                case "save":
+                    var storeBlob = store.GetStoreBlob();
+                    storeBlob.CoinSwitchSettings = coinSwitchSettings;
+                    store.SetStoreBlob(storeBlob);
+                    await _Repo.UpdateStore(store);
+                    StatusMessage = "CoinSwitch settings modified";
+                    return RedirectToAction(nameof(UpdateStore), new {
+                        storeId});
+
+                default:
+                    return View(vm);
+            }
+        }
+    }
+}

BTCPayServer/Controllers/StoresController.Email.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models.ServerViewModels;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Services.Mails;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class StoresController
+    {
+        
+        [Route("{storeId}/emails")]
+        public IActionResult Emails()
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            var data = store.GetStoreBlob().EmailSettings ?? new EmailSettings();
+            return View(new EmailsViewModel() { Settings = data });
+        }
+        
+        [Route("{storeId}/emails")]
+        [HttpPost]
+        public async Task<IActionResult> Emails(string storeId, EmailsViewModel model, string command)
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            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";
+                }
+                catch (Exception ex)
+                {
+                    model.StatusMessage = "Error: " + ex.Message;
+                }
+                return View(model);
+            }
+            else // if(command == "Save")
+            {
+                
+                var storeBlob = store.GetStoreBlob();
+                storeBlob.EmailSettings = model.Settings;
+                store.SetStoreBlob(storeBlob);
+                await _Repo.UpdateStore(store);
+                StatusMessage = "Email settings modified";
+                return RedirectToAction(nameof(UpdateStore), new {
+                    storeId});
+
+            }
+        }
+    }
+}

BTCPayServer/Controllers/StoresController.LightningLike.cs

@@ -27,7 +27,8 @@ namespace BTCPayServer.Controllers
             LightningNodeViewModel vm = new LightningNodeViewModel
             {
                 CryptoCode = cryptoCode,
-                InternalLightningNode = GetInternalLighningNode(cryptoCode)?.ToString()
+                InternalLightningNode = GetInternalLighningNode(cryptoCode)?.ToString(),
+                StoreId = storeId
             };
             SetExistingValues(store, vm);
             return View(vm);
@@ -154,7 +155,7 @@ namespace BTCPayServer.Controllers
                     var handler = (LightningLikePaymentHandler)_ServiceProvider.GetRequiredService<IPaymentMethodHandler<Payments.Lightning.LightningSupportedPaymentMethod>>();
                     try
                     {
-                        var info = await handler.Test(paymentMethod, network);
+                        var info = await handler.GetNodeInfo(paymentMethod, network);
                         if (!vm.SkipPortTest)
                         {
                             using (CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(20)))

BTCPayServer/Controllers/StoresController.cs

@@ -10,7 +10,9 @@ using BTCPayServer.Data;
 using BTCPayServer.Models;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments;
 using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Rating;
 using BTCPayServer.Security;
 using BTCPayServer.Services;
@@ -94,6 +96,11 @@ namespace BTCPayServer.Controllers
         {
             get; set;
         }
+        [TempData]
+        public bool StoreNotConfigured
+        {
+            get; set;
+        }
 
         [HttpGet]
         [Route("{storeId}/users")]
@@ -165,7 +172,7 @@ namespace BTCPayServer.Controllers
             return View("Confirm", new ConfirmModel()
             {
                 Title = $"Remove store user",
-                Description = $"Are you sure to remove access to remove access to {user.Email}?",
+                Description = $"Are you sure you want to remove store access for {user.Email}?",
                 Action = "Delete"
             });
         }
@@ -324,7 +331,7 @@ namespace BTCPayServer.Controllers
         {
             var storeBlob = StoreData.GetStoreBlob();
             var vm = new CheckoutExperienceViewModel();
-            vm.SetCryptoCurrencies(_ExplorerProvider, StoreData.GetDefaultCrypto(_NetworkProvider));
+            SetCryptoCurrencies(vm, StoreData);
             vm.SetLanguages(_LangService, storeBlob.DefaultLang);
             vm.LightningMaxValue = storeBlob.LightningMaxValue?.ToString() ?? "";
             vm.OnChainMinValue = storeBlob.OnChainMinValue?.ToString() ?? "";
@@ -334,6 +341,23 @@ namespace BTCPayServer.Controllers
             vm.HtmlTitle = storeBlob.HtmlTitle;
             return View(vm);
         }
+        void SetCryptoCurrencies(CheckoutExperienceViewModel vm, Data.StoreData storeData)
+        {
+            var choices = storeData.GetEnabledPaymentIds(_NetworkProvider)
+                                      .Select(o => new CheckoutExperienceViewModel.Format() { Name = GetDisplayName(o), Value = o.ToString(), PaymentId = o }).ToArray();
+
+            var defaultPaymentId = storeData.GetDefaultPaymentId(_NetworkProvider);
+            var chosen = choices.FirstOrDefault(c => c.PaymentId == defaultPaymentId);
+            vm.CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen?.Value);
+            vm.DefaultPaymentMethod = chosen?.Value;
+        }
+
+        private string GetDisplayName(PaymentMethodId paymentMethodId)
+        {
+            var display = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode)?.DisplayName ?? paymentMethodId.CryptoCode;
+            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
+                display : $"{display} (Lightning)";
+        }
 
         [HttpPost]
         [Route("{storeId}/checkout")]
@@ -358,12 +382,13 @@ namespace BTCPayServer.Controllers
             }
             bool needUpdate = false;
             var blob = StoreData.GetStoreBlob();
-            if (StoreData.GetDefaultCrypto(_NetworkProvider) != model.DefaultCryptoCurrency)
+            var defaultPaymentMethodId = model.DefaultPaymentMethod == null ? null : PaymentMethodId.Parse(model.DefaultPaymentMethod);
+            if (StoreData.GetDefaultPaymentId(_NetworkProvider) != defaultPaymentMethodId)
             {
                 needUpdate = true;
-                StoreData.SetDefaultCrypto(model.DefaultCryptoCurrency);
+                StoreData.SetDefaultPaymentId(defaultPaymentMethodId);
             }
-            model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
+            SetCryptoCurrencies(model, StoreData);
             model.SetLanguages(_LangService, model.DefaultLang);
 
             if (!ModelState.IsValid)
@@ -406,7 +431,7 @@ namespace BTCPayServer.Controllers
             vm.Id = store.Id;
             vm.StoreName = store.StoreName;
             vm.StoreWebsite = store.StoreWebsite;
-            vm.NetworkFee = !storeBlob.NetworkFeeDisabled;
+            vm.NetworkFeeMode = storeBlob.NetworkFeeMode;
             vm.AnyoneCanCreateInvoice = storeBlob.AnyoneCanInvoice;
             vm.SpeedPolicy = store.SpeedPolicy;
             vm.CanDelete = _Repo.CanDeleteStores();
@@ -464,6 +489,14 @@ namespace BTCPayServer.Controllers
                 Action = nameof(UpdateChangellySettings),
                 Provider = "Changelly"
             });
+            
+            var coinSwitchEnabled = storeBlob.CoinSwitchSettings != null && storeBlob.CoinSwitchSettings.Enabled;
+            vm.ThirdPartyPaymentMethods.Add(new StoreViewModel.ThirdPartyPaymentMethod()
+            {
+                Enabled = coinSwitchEnabled,
+                Action = nameof(UpdateCoinSwitchSettings),
+                Provider = "CoinSwitch"
+            });
         }
 
         [HttpPost]
@@ -489,7 +522,7 @@ namespace BTCPayServer.Controllers
 
             var blob = StoreData.GetStoreBlob();
             blob.AnyoneCanInvoice = model.AnyoneCanCreateInvoice;
-            blob.NetworkFeeDisabled = !model.NetworkFee;
+            blob.NetworkFeeMode = model.NetworkFeeMode;
             blob.MonitoringExpiration = model.MonitoringExpiration;
             blob.InvoiceExpiration = model.InvoiceExpiration;
             blob.LightningDescriptionTemplate = model.LightningDescriptionTemplate ?? string.Empty;
@@ -557,6 +590,7 @@ namespace BTCPayServer.Controllers
             var model = new TokensViewModel();
             var tokens = await _TokenRepository.GetTokensByStoreIdAsync(StoreData.Id);
             model.StatusMessage = StatusMessage;
+            model.StoreNotConfigured = StoreNotConfigured;
             model.Tokens = tokens.Select(t => new TokenViewModel()
             {
                 Facade = t.Facade,
@@ -784,6 +818,10 @@ namespace BTCPayServer.Controllers
             var pairingResult = await _TokenRepository.PairWithStoreAsync(pairingCode, store.Id);
             if (pairingResult == PairingResult.Complete || pairingResult == PairingResult.Partial)
             {
+                var excludeFilter = store.GetStoreBlob().GetExcludedPaymentMethods();
+                StoreNotConfigured = store.GetSupportedPaymentMethods(_NetworkProvider)
+                                          .Where(p => !excludeFilter.Match(p.PaymentId))
+                                          .Count() == 0;
                 StatusMessage = "Pairing is successful";
                 if (pairingResult == PairingResult.Partial)
                     StatusMessage = "Server initiated pairing code: " + pairingCode;

BTCPayServer/Controllers/WalletsController.cs

@@ -146,7 +146,7 @@ namespace BTCPayServer.Controllers
         [Route("{walletId}/send")]
         public async Task<IActionResult> WalletSend(
             [ModelBinder(typeof(WalletIdModelBinder))]
-            WalletId walletId, string defaultDestination = null, string defaultAmount = null)
+            WalletId walletId, string defaultDestination = null, string defaultAmount = null, bool advancedMode = false)
         {
             if (walletId?.StoreId == null)
                 return NotFound();
@@ -195,6 +195,7 @@ namespace BTCPayServer.Controllers
                 }
                 catch (Exception ex) { model.RateError = ex.Message; }
             }
+            model.AdvancedMode = advancedMode;
             return View(model);
         }
 
@@ -202,7 +203,7 @@ namespace BTCPayServer.Controllers
         [Route("{walletId}/send")]
         public async Task<IActionResult> WalletSend(
             [ModelBinder(typeof(WalletIdModelBinder))]
-            WalletId walletId, WalletSendModel vm)
+            WalletId walletId, WalletSendModel vm, string command = null)
         {
             if (walletId?.StoreId == null)
                 return NotFound();
@@ -212,6 +213,14 @@ namespace BTCPayServer.Controllers
             var network = this.NetworkProvider.GetNetwork(walletId?.CryptoCode);
             if (network == null)
                 return NotFound();
+
+            if (command == "noob" || command == "expert")
+            {
+                ModelState.Clear();
+                vm.AdvancedMode = command == "expert";
+                return View(vm);
+            }
+
             var destination = ParseDestination(vm.Destination, network.NBitcoinNetwork);
             if (destination == null)
                 ModelState.AddModelError(nameof(vm.Destination), "Invalid address");
@@ -231,7 +240,8 @@ namespace BTCPayServer.Controllers
                 Destination = vm.Destination,
                 Amount = vm.Amount.Value,
                 SubstractFees = vm.SubstractFees,
-                FeeSatoshiPerByte = vm.FeeSatoshiPerByte
+                FeeSatoshiPerByte = vm.FeeSatoshiPerByte,
+                NoChange = vm.NoChange
             });
         }
 
@@ -403,6 +413,7 @@ namespace BTCPayServer.Controllers
             // getxpub
             int account = 0,
             // sendtoaddress
+            bool noChange = false,
             string destination = null, string amount = null, string feeRate = null, string substractFees = null
             )
         {
@@ -410,8 +421,8 @@ namespace BTCPayServer.Controllers
                 return NotFound();
 
             var cryptoCode = walletId.CryptoCode;
-            var storeBlob = (await Repository.FindStore(walletId.StoreId, GetUserId()));
-            var derivationScheme = GetPaymentMethod(walletId, storeBlob).DerivationStrategyBase;
+            var storeData = (await Repository.FindStore(walletId.StoreId, GetUserId()));
+            var derivationScheme = GetPaymentMethod(walletId, storeData).DerivationStrategyBase;
 
             var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
 
@@ -436,7 +447,7 @@ namespace BTCPayServer.Controllers
                     {
                         try
                         {
-                            destinationAddress = BitcoinAddress.Create(destination, network.NBitcoinNetwork);
+                            destinationAddress = BitcoinAddress.Create(destination.Trim(), network.NBitcoinNetwork);
                         }
                         catch { }
                         if (destinationAddress == null)
@@ -476,15 +487,6 @@ namespace BTCPayServer.Controllers
                         }
                         catch { throw new FormatException("Invalid value for subtract fees"); }
                     }
-                    if (command == "getinfo")
-                    {
-                        var strategy = GetDirectDerivationStrategy(derivationScheme);
-                        if (strategy == null || await hw.GetKeyPath(network, strategy, normalOperationTimeout.Token) == null)
-                        {
-                            throw new Exception($"This store is not configured to use this ledger");
-                        }
-                        result = new GetInfoResult();
-                    }
                     if (command == "test")
                     {
                         result = await hw.Test(normalOperationTimeout.Token);
@@ -496,9 +498,32 @@ namespace BTCPayServer.Controllers
                         var strategy = GetDirectDerivationStrategy(derivationScheme);
                         var wallet = _walletProvider.GetWallet(network);
                         var change = wallet.GetChangeAddressAsync(derivationScheme);
+                        var keypaths = new Dictionary<Script, KeyPath>();
+                        List<Coin> availableCoins = new List<Coin>();
+                        foreach (var c in await wallet.GetUnspentCoins(derivationScheme))
+                        {
+                            keypaths.TryAdd(c.Coin.ScriptPubKey, c.KeyPath);
+                            availableCoins.Add(c.Coin);
+                        }
 
-                        var unspentCoins = await wallet.GetUnspentCoins(derivationScheme);
                         var changeAddress = await change;
+
+                        var storeBlob = storeData.GetStoreBlob();
+                        var paymentId = new Payments.PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike);
+                        var foundKeyPath = storeBlob.GetWalletKeyPathRoot(paymentId);
+                        // Some deployment have the wallet root key path saved in the store blob
+                        // If it does, we only have to make 1 call to the hw to check if it can sign the given strategy,
+                        if (foundKeyPath == null || !await hw.CanSign(network, strategy, foundKeyPath, normalOperationTimeout.Token))
+                        {
+                            // If the saved wallet key path is not present or incorrect, let's scan the wallet to see if it can sign strategy
+                            foundKeyPath = await hw.FindKeyPath(network, strategy, normalOperationTimeout.Token);
+                            if (foundKeyPath == null)
+                                throw new HardwareWalletException($"This store is not configured to use this ledger");
+                            storeBlob.SetWalletKeyPathRoot(paymentId, foundKeyPath);
+                            storeData.SetStoreBlob(storeBlob);
+                            await Repository.UpdateStore(storeData);
+                        }
+retry:
                         var send = new[] { (
                         destination: destinationAddress as IDestination,
                         amount: amountBTC,
@@ -514,15 +539,9 @@ namespace BTCPayServer.Controllers
                                 throw new ArgumentOutOfRangeException(nameof(element.amount), "The amount should be above zero");
                         }
 
-                        var foundKeyPath = await hw.GetKeyPath(network, strategy, normalOperationTimeout.Token);
-                        if (foundKeyPath == null)
-                        {
-                            throw new HardwareWalletException($"This store is not configured to use this ledger");
-                        }
-
                         TransactionBuilder builder = network.NBitcoinNetwork.CreateTransactionBuilder();
                         builder.StandardTransactionPolicy.MinRelayTxFee = summary.Status.BitcoinStatus.MinRelayTxFee;
-                        builder.AddCoins(unspentCoins.Select(c => c.Coin).ToArray());
+                        builder.AddCoins(availableCoins);
 
                         foreach (var element in send)
                         {
@@ -530,6 +549,7 @@ namespace BTCPayServer.Controllers
                             if (element.substractFees)
                                 builder.SubtractFees();
                         }
+
                         builder.SetChange(changeAddress.Item1);
 
                         if (network.MinFee == null)
@@ -546,13 +566,15 @@ namespace BTCPayServer.Controllers
                         }
                         var unsigned = builder.BuildTransaction(false);
 
-                        var keypaths = new Dictionary<Script, KeyPath>();
-                        foreach (var c in unspentCoins)
+                        var hasChange = unsigned.Outputs.Any(o => o.ScriptPubKey == changeAddress.Item1.ScriptPubKey);
+                        if (noChange && hasChange)
                         {
-                            keypaths.TryAdd(c.Coin.ScriptPubKey, c.KeyPath);
+                            availableCoins = builder.FindSpentCoins(unsigned).Cast<Coin>().ToList();
+                            amountBTC = builder.FindSpentCoins(unsigned).Select(c => c.TxOut.Value).Sum();
+                            subsctractFeesValue = true;
+                            goto retry;
                         }
 
-                        var hasChange = unsigned.Outputs.Count == 2;
                         var usedCoins = builder.FindSpentCoins(unsigned);
 
                         Dictionary<uint256, Transaction> parentTransactions = new Dictionary<uint256, Transaction>();

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/ApplicationDbContextFactory.cs

@@ -3,8 +3,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using Hangfire;
-using Hangfire.MemoryStorage;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
 using JetBrains.Annotations;
@@ -98,15 +96,5 @@ namespace BTCPayServer.Data
             else if (_Type == DatabaseType.MySQL)
                 builder.UseMySql(_ConnectionString);
         }
-
-        public void ConfigureHangfireBuilder(IGlobalConfiguration builder)
-        {
-            builder.UseMemoryStorage();
-            //We always use memory storage because of incompatibilities with the latest postgres in 2.1
-            //if (_Type == DatabaseType.Sqlite)
-            //    builder.UseMemoryStorage(); //Sqlite provider does not support multiple workers
-            //else if (_Type == DatabaseType.Postgres)
-            //    builder.UsePostgreSqlStorage(_ConnectionString);
-        }
     }
 }

BTCPayServer/Data/StoreData.cs

@@ -18,8 +18,10 @@ using System.ComponentModel.DataAnnotations;
 using BTCPayServer.Services;
 using System.Security.Claims;
 using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.CoinSwitch;
 using BTCPayServer.Security;
 using BTCPayServer.Rating;
+using BTCPayServer.Services.Mails;
 
 namespace BTCPayServer.Data
 {
@@ -54,7 +56,6 @@ namespace BTCPayServer.Data
             get;
             set;
         }
-
         public IEnumerable<ISupportedPaymentMethod> GetSupportedPaymentMethods(BTCPayNetworkProvider networks)
         {
 #pragma warning disable CS0618
@@ -193,7 +194,7 @@ namespace BTCPayServer.Data
             get;
             set;
         }
-        [Obsolete("Use GetDefaultCrypto instead")]
+        [Obsolete("Use GetDefaultPaymentId instead")]
         public string DefaultCrypto { get; set; }
         public List<PairedSINData> PairedSINs { get; set; }
         public IEnumerable<APIKeyData> APIKeys { get; set; }
@@ -202,13 +203,32 @@ namespace BTCPayServer.Data
         public List<Claim> AdditionalClaims { get; set; } = new List<Claim>();
 
 #pragma warning disable CS0618
-        public string GetDefaultCrypto(BTCPayNetworkProvider networkProvider = null)
+        public PaymentMethodId GetDefaultPaymentId(BTCPayNetworkProvider networks)
         {
-            return DefaultCrypto ?? (networkProvider == null ? "BTC" : GetSupportedPaymentMethods(networkProvider).Select(p => p.PaymentId.CryptoCode).FirstOrDefault() ?? "BTC");
+            PaymentMethodId[] paymentMethodIds = GetEnabledPaymentIds(networks);
+
+            var defaultPaymentId = string.IsNullOrEmpty(DefaultCrypto) ? null : PaymentMethodId.Parse(DefaultCrypto);
+            var chosen = paymentMethodIds.FirstOrDefault(f => f == defaultPaymentId) ??
+                         paymentMethodIds.FirstOrDefault(f => f.CryptoCode == defaultPaymentId?.CryptoCode) ??
+                         paymentMethodIds.FirstOrDefault();
+            return chosen;
         }
-        public void SetDefaultCrypto(string defaultCryptoCurrency)
+
+        public PaymentMethodId[] GetEnabledPaymentIds(BTCPayNetworkProvider networks)
         {
-            DefaultCrypto = defaultCryptoCurrency;
+            var excludeFilter = GetStoreBlob().GetExcludedPaymentMethods();
+            var paymentMethodIds = GetSupportedPaymentMethods(networks).Select(p => p.PaymentId)
+                                .Where(a => !excludeFilter.Match(a))
+                                .OrderByDescending(a => a.CryptoCode == "BTC")
+                                .ThenBy(a => a.CryptoCode)
+                                .ThenBy(a => a.PaymentType == PaymentTypes.LightningLike ? 1 : 0)
+                                .ToArray();
+            return paymentMethodIds;
+        }
+
+        public void SetDefaultPaymentId(PaymentMethodId defaultPaymentId)
+        {
+            DefaultCrypto = defaultPaymentId.ToString();
         }
 #pragma warning restore CS0618
 
@@ -249,6 +269,12 @@ namespace BTCPayServer.Data
         }
     }
 
+    public enum NetworkFeeMode
+    {
+        MultiplePaymentsOnly,
+        Always,
+        Never
+    }
     public class StoreBlob
     {
         public StoreBlob()
@@ -258,10 +284,21 @@ namespace BTCPayServer.Data
             PaymentTolerance = 0;
             RequiresRefundEmail = true;
         }
-        public bool NetworkFeeDisabled
+
+        [Obsolete("Use NetworkFeeMode instead")]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool? NetworkFeeDisabled
         {
             get; set;
         }
+
+        [JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+        public NetworkFeeMode NetworkFeeMode
+        {
+            get;
+            set;
+        }
+
         public bool RequiresRefundEmail { get; set; }
 
         public string DefaultLang { get; set; }
@@ -305,6 +342,7 @@ namespace BTCPayServer.Data
         public bool AnyoneCanInvoice { get; set; }
         
         public ChangellySettings ChangellySettings { get; set; }
+        public CoinSwitchSettings CoinSwitchSettings { get; set; }
 
 
         string _LightningDescriptionTemplate;
@@ -366,6 +404,25 @@ namespace BTCPayServer.Data
 
         [Obsolete("Use GetExcludedPaymentMethods instead")]
         public string[] ExcludedPaymentMethods { get; set; }
+#pragma warning disable CS0618 // Type or member is obsolete
+        public void SetWalletKeyPathRoot(PaymentMethodId paymentMethodId, KeyPath keyPath)
+        {
+            if (keyPath == null)
+                WalletKeyPathRoots.Remove(paymentMethodId.ToString());
+            else
+                WalletKeyPathRoots.AddOrReplace(paymentMethodId.ToString().ToLowerInvariant(), keyPath.ToString());
+        }
+        public KeyPath GetWalletKeyPathRoot(PaymentMethodId paymentMethodId)
+        {
+            if (WalletKeyPathRoots.TryGetValue(paymentMethodId.ToString().ToLowerInvariant(), out var k))
+                return KeyPath.Parse(k);
+            return null;
+        }
+#pragma warning restore CS0618 // Type or member is obsolete
+        [Obsolete("Use SetWalletKeyPathRoot/GetWalletKeyPathRoot instead")]
+        public Dictionary<string, string> WalletKeyPathRoots { get; set; } = new Dictionary<string, string>();
+
+        public EmailSettings EmailSettings { get; set; }
 
         public IPaymentFilter GetExcludedPaymentMethods()
         {

BTCPayServer/Events/InvoiceEvent.cs

@@ -8,17 +8,31 @@ namespace BTCPayServer.Events
 {
     public class InvoiceEvent
     {
-        public InvoiceEvent(Models.InvoiceResponse invoice, int code, string name)
+        public const string Created = "invoice_created";
+        public const string ReceivedPayment = "invoice_receivedPayment";
+        public const string MarkedCompleted = "invoice_markedComplete";
+        public const string MarkedInvalid= "invoice_markedInvalid";
+        public const string Expired= "invoice_expired";
+        public const string ExpiredPaidPartial= "invoice_expiredPaidPartial";
+        public const string PaidInFull= "invoice_paidInFull";
+        public const string PaidAfterExpiration= "invoice_paidAfterExpiration";
+        public const string FailedToConfirm= "invoice_failedToConfirm";
+        public const string Confirmed= "invoice_confirmed";
+        public const string Completed= "invoice_completed";
+        
+        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; }
 
+        public PaymentEntity Payment { get; set; }
+
         public override string ToString()
         {
             return $"Invoice {Invoice.Id} new event: {Name} ({EventCode})";

BTCPayServer/Extensions/EmailSenderExtensions.cs

@@ -10,9 +10,9 @@ namespace BTCPayServer.Services
 {
     public static class EmailSenderExtensions
     {
-        public static Task SendEmailConfirmationAsync(this IEmailSender emailSender, string email, string link)
+        public static void SendEmailConfirmation(this IEmailSender emailSender, string email, string link)
         {
-            return emailSender.SendEmailAsync(email, "Confirm your email",
+            emailSender.SendEmail(email, "Confirm your email",
                 $"Please confirm your account by clicking this link: <a href='{HtmlEncoder.Default.Encode(link)}'>link</a>");
         }
     }

BTCPayServer/Filters/XFrameOptionsAttribute.cs

@@ -12,13 +12,32 @@ namespace BTCPayServer.Filters
         {
             Value = value;
         }
-        public string Value
+
+        public XFrameOptionsAttribute(XFrameOptions type, string allowFrom = null)
         {
-            get; set;
+            switch (type)
+            {
+                case XFrameOptions.Deny:
+                    Value = "deny";
+                    break;
+                case XFrameOptions.SameOrigin:
+                    Value = "deny";
+                    break;
+                case XFrameOptions.AllowFrom:
+                    Value = $"allow-from {allowFrom}";
+                    break;
+                case XFrameOptions.AllowAll:
+                    Value = "allow-all";
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type), type, null);
+            }
         }
+
+        public string Value { get; set; }
+
         public void OnActionExecuted(ActionExecutedContext context)
         {
-
         }
 
         public void OnActionExecuting(ActionExecutingContext context)
@@ -28,5 +47,13 @@ namespace BTCPayServer.Filters
                 context.HttpContext.Response.SetHeaderOnStarting("X-Frame-Options", Value);
             }
         }
+
+        public enum XFrameOptions
+        {
+            Deny,
+            SameOrigin,
+            AllowFrom,
+            AllowAll
+        }
     }
 }

BTCPayServer/HostedServices/BackgroundJobSchedulerHostedService.cs

@@ -0,0 +1,133 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using BTCPayServer.Services;
+using Microsoft.Extensions.Hosting;
+using NicolasDorier.RateLimits;
+
+namespace BTCPayServer.HostedServices
+{
+    public class BackgroundJobSchedulerHostedService : IHostedService
+    {
+        public BackgroundJobSchedulerHostedService(IBackgroundJobClient backgroundJobClient)
+        {
+            BackgroundJobClient = (BackgroundJobClient)backgroundJobClient;
+        }
+
+        public BackgroundJobClient BackgroundJobClient { get; }
+
+        Task _Loop;
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Stop = new CancellationTokenSource();
+            _Loop = BackgroundJobClient.ProcessJobs(_Stop.Token);
+            return Task.CompletedTask;
+        }
+
+        CancellationTokenSource _Stop;
+
+        public async Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Stop.Cancel();
+            try
+            {
+                await _Loop;
+            }
+            catch (OperationCanceledException)
+            {
+
+            }
+            await BackgroundJobClient.WaitAllRunning(cancellationToken);
+        }
+    }
+
+    public class BackgroundJobClient : IBackgroundJobClient
+    {
+        class BackgroundJob
+        {
+            public Func<Task> Action;
+            public TimeSpan Delay;
+            public IDelay DelayImplementation;
+            public BackgroundJob(Func<Task> action, TimeSpan delay, IDelay delayImplementation)
+            {
+                this.Action = action;
+                this.Delay = delay;
+                this.DelayImplementation = delayImplementation;
+            }
+
+            public async Task Run(CancellationToken cancellationToken)
+            {
+                await DelayImplementation.Wait(Delay, cancellationToken);
+                await Action();
+            }
+        }
+
+        public IDelay Delay { get; set; } = TaskDelay.Instance;
+        public int GetExecutingCount()
+        {
+            lock (_Processing)
+            {
+                return _Processing.Count();
+            }
+        }
+
+        private Channel<BackgroundJob> _Jobs = Channel.CreateUnbounded<BackgroundJob>();
+        HashSet<Task> _Processing = new HashSet<Task>();
+        public void Schedule(Func<Task> action, TimeSpan delay)
+        {
+            _Jobs.Writer.TryWrite(new BackgroundJob(action, delay, Delay));
+        }
+
+        public async Task WaitAllRunning(CancellationToken cancellationToken)
+        {
+            Task[] processing = null;
+            lock (_Processing)
+            {
+                processing = _Processing.ToArray();
+            }
+
+            try
+            {
+                await Task.WhenAll(processing).WithCancellation(cancellationToken);
+            }
+            catch (Exception) when (cancellationToken.IsCancellationRequested)
+            {
+                throw;
+            }
+        }
+
+        public async Task ProcessJobs(CancellationToken cancellationToken)
+        {
+            while (await _Jobs.Reader.WaitToReadAsync(cancellationToken))
+            {
+                if (_Jobs.Reader.TryRead(out var job))
+                {
+                    var processing = job.Run(cancellationToken);
+                    lock (_Processing)
+                    {
+                        _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 =>
+                    {
+                        if (t.IsFaulted)
+                        {
+                            Logs.PayServer.LogWarning(t.Exception, "Unhandled exception while job running");
+                        }
+                        lock (_Processing)
+                        {
+                            _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/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 Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Subscriptions = new List<IEventAggregatorSubscription>();
+            SubscibeToEvents();
+            _Cts = new CancellationTokenSource();
+            _ProcessingEvents = ProcessEvents(_Cts.Token);
+            return Task.CompletedTask;
+        }
+        Task _ProcessingEvents = Task.CompletedTask;
+
+        public async Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Subscriptions?.ForEach(subscription => subscription.Dispose());
+            _Cts?.Cancel();
+            try
+            {
+                await _ProcessingEvents;
+            }
+            catch (OperationCanceledException)
+            { }
+        }
+    }
+}

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -1,10 +1,7 @@
-using Hangfire;
-using Hangfire.Common;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using Hangfire.Annotations;
 using System.Reflection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
@@ -21,6 +18,7 @@ using NBXplorer;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Payments;
 using BTCPayServer.Services.Mails;
+using BTCPayServer.Services;
 
 namespace BTCPayServer.HostedServices
 {
@@ -35,25 +33,17 @@ namespace BTCPayServer.HostedServices
                 get; set;
             }
 
-            public InvoiceEntity Invoice
+            public InvoicePaymentNotificationEventWrapper Notification
             {
                 get; set;
             }
-
-            public int? EventCode { get; set; }
-            public string Message { get; set; }
-        }
-
-        public ILogger Logger
-        {
-            get; set;
         }
 
         IBackgroundJobClient _JobClient;
         EventAggregator _EventAggregator;
         InvoiceRepository _InvoiceRepository;
         BTCPayNetworkProvider _NetworkProvider;
-        IEmailSender _EmailSender;
+        private readonly EmailSenderFactory _EmailSenderFactory;
 
         public InvoiceNotificationManager(
             IBackgroundJobClient jobClient,
@@ -61,102 +51,114 @@ namespace BTCPayServer.HostedServices
             InvoiceRepository invoiceRepository,
             BTCPayNetworkProvider networkProvider,
             ILogger<InvoiceNotificationManager> logger,
-            IEmailSender emailSender)
+            EmailSenderFactory emailSenderFactory)
         {
-            Logger = logger as ILogger ?? NullLogger.Instance;
             _JobClient = jobClient;
             _EventAggregator = eventAggregator;
             _InvoiceRepository = invoiceRepository;
             _NetworkProvider = networkProvider;
-            _EmailSender = emailSender;
+            _EmailSenderFactory = emailSenderFactory;
         }
 
-        async Task Notify(InvoiceEntity invoice, int? eventCode = null, string name = null)
+        void Notify(InvoiceEntity invoice, InvoiceEvent invoiceEvent, bool extendedNotification)
         {
+            var dto = invoice.EntityToDTO(_NetworkProvider);
+            var notification = new InvoicePaymentNotificationEventWrapper()
+            {
+                Data = new InvoicePaymentNotification()
+                {
+                    Id = dto.Id,
+                    Currency = dto.Currency,
+                    CurrentTime = dto.CurrentTime,
+                    ExceptionStatus = dto.ExceptionStatus,
+                    ExpirationTime = dto.ExpirationTime,
+                    InvoiceTime = dto.InvoiceTime,
+                    PosData = dto.PosData,
+                    Price = dto.Price,
+                    Status = dto.Status,
+                    BuyerFields = invoice.RefundMail == null ? null : new Newtonsoft.Json.Linq.JObject() { new JProperty("buyerEmail", invoice.RefundMail) },
+                    PaymentSubtotals = dto.PaymentSubtotals,
+                    PaymentTotals = dto.PaymentTotals,
+                    AmountPaid = dto.AmountPaid,
+                    ExchangeRates = dto.ExchangeRates,
+                },
+                Event = new InvoicePaymentNotificationEvent()
+                {
+                    Code = invoiceEvent.EventCode,
+                    Name = invoiceEvent.Name
+                },
+                ExtendedNotification = extendedNotification,
+                NotificationURL = invoice.NotificationURL
+            };
+
+            // For lightning network payments, paid, confirmed and completed come all at once.
+            // So despite the event is "paid" or "confirmed" the Status of the invoice is technically complete
+            // This confuse loggers who think their endpoint get duplicated events
+            // So here, we just override the status expressed by the notification
+            if (invoiceEvent.Name == InvoiceEvent.Confirmed)
+            {
+                notification.Data.Status = InvoiceState.ToString(InvoiceStatus.Confirmed);
+            }
+            if (invoiceEvent.Name == InvoiceEvent.PaidInFull)
+            {
+                notification.Data.Status = InvoiceState.ToString(InvoiceStatus.Paid);
+            }
+            //////////////////
+
+            // We keep backward compatibility with bitpay by passing BTC info to the notification
+            // we don't pass other info, as it is a bad idea to use IPN data for logic processing (can be faked)
+            var btcCryptoInfo = dto.CryptoInfo.FirstOrDefault(c => c.GetpaymentMethodId() == new PaymentMethodId("BTC", Payments.PaymentTypes.BTCLike));
+            if (btcCryptoInfo != null)
+            {
+#pragma warning disable CS0618
+                notification.Data.Rate = dto.Rate;
+                notification.Data.Url = dto.Url;
+                notification.Data.BTCDue = dto.BTCDue;
+                notification.Data.BTCPaid = dto.BTCPaid;
+                notification.Data.BTCPrice = dto.BTCPrice;
+#pragma warning restore CS0618
+            }
+
             CancellationTokenSource cts = new CancellationTokenSource(10000);
 
             if (!String.IsNullOrEmpty(invoice.NotificationEmail))
             {
-                // just extracting most important data for email body, merchant should query API back for full invoice based on Invoice.Id
-                var ipn = new
-                {
-                    invoice.Id,
-                    invoice.Status,
-                    invoice.StoreId
-                };
-                // TODO: Consider adding info on ItemDesc and payment info (amount)
+                var emailBody = NBitcoin.JsonConverters.Serializer.ToString(notification);
+
+                _EmailSenderFactory.GetEmailSender(invoice.StoreId).SendEmail(
+                    invoice.NotificationEmail,
+                    $"BtcPayServer Invoice Notification - ${invoice.StoreId}",
+                    emailBody);
 
-                var emailBody = NBitcoin.JsonConverters.Serializer.ToString(ipn);
-                await _EmailSender.SendEmailAsync(
-                    invoice.NotificationEmail, $"BtcPayServer Invoice Notification - ${invoice.StoreId}", emailBody);
             }
-
-            try
-            {
-                if (string.IsNullOrEmpty(invoice.NotificationURL))
-                    return;
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name));
-                var response = await SendNotification(invoice, eventCode, name, cts.Token);
-                response.EnsureSuccessStatusCode();
+            if (string.IsNullOrEmpty(invoice.NotificationURL) || !Uri.IsWellFormedUriString(invoice.NotificationURL, UriKind.Absolute))
                 return;
-            }
-            catch (OperationCanceledException) when (cts.IsCancellationRequested)
-            {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
-                {
-                    Error = "Timeout"
-                });
-            }
-            catch (Exception ex) // It fails, it is OK because we try with hangfire after
-            {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
-                {
-                    Error = ex.Message
-                });
-            }
-            var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Invoice = invoice, EventCode = eventCode, Message = name });
+            var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Notification = notification });
             if (!string.IsNullOrEmpty(invoice.NotificationURL))
                 _JobClient.Schedule(() => NotifyHttp(invoiceStr), TimeSpan.Zero);
         }
 
-        ConcurrentDictionary<string, string> _Executing = new ConcurrentDictionary<string, string>();
         public async Task NotifyHttp(string invoiceData)
         {
             var job = NBitcoin.JsonConverters.Serializer.ToObject<ScheduledJob>(invoiceData);
-            var jobId = GetHttpJobId(job.Invoice);
-
-            if (!_Executing.TryAdd(jobId, jobId))
-                return; //For some reason, Hangfire fire the job several time
-
-            Logger.LogInformation("Running " + jobId);
             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.Invoice, job.EventCode, job.Message, cts.Token);
+                HttpResponseMessage response = await SendNotification(job.Notification, cts.Token);
                 reschedule = !response.IsSuccessStatusCode;
-                Logger.LogInformation("Job " + jobId + " returned " + response.StatusCode);
-
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
-                {
-                    Error = reschedule ? $"Unexpected return code: {(int)response.StatusCode}" : null
-                });
+                aggregatorEvent.Error = reschedule ? $"Unexpected return code: {(int)response.StatusCode}" : null;
+                _EventAggregator.Publish<InvoiceIPNEvent>(aggregatorEvent);
             }
             catch (OperationCanceledException) when (cts.IsCancellationRequested)
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
-                {
-                    Error = "Timeout"
-                });
+                aggregatorEvent.Error = "Timeout";
+                _EventAggregator.Publish<InvoiceIPNEvent>(aggregatorEvent);
                 reschedule = true;
-                Logger.LogInformation("Job " + jobId + " timed out");
             }
-            catch (Exception ex) // It fails, it is OK because we try with hangfire after
+            catch (Exception ex)
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
-                {
-                    Error = ex.Message
-                });
                 reschedule = true;
 
                 List<string> messages = new List<string>();
@@ -166,21 +168,16 @@ namespace BTCPayServer.HostedServices
                     ex = ex.InnerException;
                 }
                 string message = String.Join(',', messages.ToArray());
-                Logger.LogInformation("Job " + jobId + " threw exception " + message);
 
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
-                {
-                    Error = $"Unexpected error: {message}"
-                });
+                aggregatorEvent.Error = $"Unexpected error: {message}";
+                _EventAggregator.Publish<InvoiceIPNEvent>(aggregatorEvent);
             }
-            finally { cts.Dispose(); _Executing.TryRemove(jobId, out jobId); }
+            finally { cts?.Dispose(); }
 
             job.TryCount++;
 
             if (job.TryCount < MaxTry && reschedule)
             {
-                Logger.LogInformation("Rescheduling " + jobId + " in 10 minutes, remaining try " + (MaxTry - job.TryCount));
-
                 invoiceData = NBitcoin.JsonConverters.Serializer.ToString(job);
                 _JobClient.Schedule(() => NotifyHttp(invoiceData), TimeSpan.FromMinutes(10.0));
             }
@@ -199,64 +196,35 @@ namespace BTCPayServer.HostedServices
             public InvoicePaymentNotificationEvent Event { get; set; }
             [JsonProperty("data")]
             public InvoicePaymentNotification Data { get; set; }
+            [JsonProperty("extendedNotification")]
+            public bool ExtendedNotification { get; set; }
+            [JsonProperty(PropertyName = "notificationURL")]
+            public string NotificationURL { get; set; }
         }
 
         Encoding UTF8 = new UTF8Encoding(false);
-        private async Task<HttpResponseMessage> SendNotification(InvoiceEntity invoice, int? eventCode, string name, CancellationToken cancellation)
+        private async Task<HttpResponseMessage> SendNotification(InvoicePaymentNotificationEventWrapper notification, CancellationToken cancellation)
         {
             var request = new HttpRequestMessage();
             request.Method = HttpMethod.Post;
 
-            var dto = invoice.EntityToDTO(_NetworkProvider);
-            InvoicePaymentNotification notification = new InvoicePaymentNotification()
-            {
-                Id = dto.Id,
-                Currency = dto.Currency,
-                CurrentTime = dto.CurrentTime,
-                ExceptionStatus = dto.ExceptionStatus,
-                ExpirationTime = dto.ExpirationTime,
-                InvoiceTime = dto.InvoiceTime,
-                PosData = dto.PosData,
-                Price = dto.Price,
-                Status = dto.Status,
-                BuyerFields = invoice.RefundMail == null ? null : new Newtonsoft.Json.Linq.JObject() { new JProperty("buyerEmail", invoice.RefundMail) },
-                PaymentSubtotals = dto.PaymentSubtotals,
-                PaymentTotals = dto.PaymentTotals,
-                AmountPaid = dto.AmountPaid,
-                ExchangeRates = dto.ExchangeRates,
+            var notificationString = NBitcoin.JsonConverters.Serializer.ToString(notification);
+            var jobj = JObject.Parse(notificationString);
 
-            };
-
-            // We keep backward compatibility with bitpay by passing BTC info to the notification
-            // we don't pass other info, as it is a bad idea to use IPN data for logic processing (can be faked)
-            var btcCryptoInfo = dto.CryptoInfo.FirstOrDefault(c => c.GetpaymentMethodId() == new PaymentMethodId("BTC", Payments.PaymentTypes.BTCLike));
-            if (btcCryptoInfo != null)
+            if (notification.ExtendedNotification)
             {
-#pragma warning disable CS0618
-                notification.Rate = dto.Rate;
-                notification.Url = dto.Url;
-                notification.BTCDue = dto.BTCDue;
-                notification.BTCPaid = dto.BTCPaid;
-                notification.BTCPrice = dto.BTCPrice;
-#pragma warning restore CS0618
-            }
-
-            string notificationString = null;
-            if (eventCode.HasValue)
-            {
-                var wrapper = new InvoicePaymentNotificationEventWrapper();
-                wrapper.Data = notification;
-                wrapper.Event = new InvoicePaymentNotificationEvent() { Code = eventCode.Value, Name = name };
-                notificationString = JsonConvert.SerializeObject(wrapper);
+                jobj.Remove("extendedNotification");
+                jobj.Remove("notificationURL");
+                notificationString = jobj.ToString();
             }
             else
             {
-                notificationString = JsonConvert.SerializeObject(notification);
+                notificationString = jobj["data"].ToString();
             }
 
-            request.RequestUri = new Uri(invoice.NotificationURL, UriKind.Absolute);
+            request.RequestUri = new Uri(notification.NotificationURL, UriKind.Absolute);
             request.Content = new StringContent(notificationString, UTF8, "application/json");
-            var response = await Enqueue(invoice.Id, async () => await _Client.SendAsync(request, cancellation));
+            var response = await Enqueue(notification.Data.Id, async () => await _Client.SendAsync(request, cancellation));
             return response;
         }
 
@@ -320,11 +288,6 @@ namespace BTCPayServer.HostedServices
 
         int MaxTry = 6;
 
-        private static string GetHttpJobId(InvoiceEntity invoice)
-        {
-            return $"{invoice.Id}-{invoice.Status}-HTTP";
-        }
-
         CompositeDisposable leases = new CompositeDisposable();
         public Task StartAsync(CancellationToken cancellationToken)
         {
@@ -341,28 +304,27 @@ namespace BTCPayServer.HostedServices
                 // we need to use the status in the event and not in the invoice. The invoice might now be in another status.
                 if (invoice.FullNotifications)
                 {
-                    if (e.Name == "invoice_expired" ||
-                       e.Name == "invoice_paidInFull" ||
-                       e.Name == "invoice_failedToConfirm" ||
-                       e.Name == "invoice_markedInvalid" ||
-                       e.Name == "invoice_markedComplete" ||
-                       e.Name == "invoice_failedToConfirm" ||
-                       e.Name == "invoice_completed" ||
-                       e.Name == "invoice_expiredPaidPartial"
+                    if (e.Name == InvoiceEvent.Expired ||
+                       e.Name == InvoiceEvent.PaidInFull ||
+                       e.Name == InvoiceEvent.FailedToConfirm ||
+                       e.Name == InvoiceEvent.MarkedInvalid ||
+                       e.Name == InvoiceEvent.MarkedCompleted ||
+                       e.Name == InvoiceEvent.FailedToConfirm ||
+                       e.Name == InvoiceEvent.Completed ||
+                       e.Name == InvoiceEvent.ExpiredPaidPartial
                      )
-                        tasks.Add(Notify(invoice));
+                        Notify(invoice, e, false);
                 }
 
-                if (e.Name == "invoice_confirmed")
+                if (e.Name == InvoiceEvent.Confirmed)
                 {
-                    tasks.Add(Notify(invoice));
+                    Notify(invoice, e, false);
                 }
 
                 if (invoice.ExtendedNotifications)
                 {
-                    tasks.Add(Notify(invoice, e.EventCode, e.Name));
+                    Notify(invoice, e, true);
                 }
-                await Task.WhenAll(tasks.ToArray());
             }));
 
 

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -11,7 +11,6 @@ using BTCPayServer.Logging;
 using System.Threading;
 using Microsoft.Extensions.Hosting;
 using System.Collections.Concurrent;
-using Hangfire;
 using BTCPayServer.Services.Wallets;
 using BTCPayServer.Controllers;
 using BTCPayServer.Events;
@@ -66,10 +65,10 @@ namespace BTCPayServer.HostedServices
                 context.MarkDirty();
                 await _InvoiceRepository.UnaffectAddress(invoice.Id);
 
-                context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1004, "invoice_expired"));
                 invoice.Status = InvoiceStatus.Expired;
-                if(invoice.ExceptionStatus == InvoiceExceptionStatus.PaidPartial)
-                    context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 2000, "invoice_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();
@@ -84,7 +83,7 @@ namespace BTCPayServer.HostedServices
                 {
                     if (invoice.Status == InvoiceStatus.New)
                     {
-                        context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1003, "invoice_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);
@@ -93,7 +92,7 @@ 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, "invoice_paidAfterExpiration"));
+                        context.Events.Add(new InvoiceEvent(invoice, 1009, InvoiceEvent.PaidAfterExpiration));
                         context.MarkDirty();
                     }
                 }
@@ -139,15 +138,15 @@ namespace BTCPayServer.HostedServices
                    (confirmedAccounting.Paid < accounting.MinimumTotalDue))
                 {
                     await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    context.Events.Add(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1013, "invoice_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, "invoice_confirmed"));
                     invoice.Status = InvoiceStatus.Confirmed;
+                    context.Events.Add(new InvoiceEvent(invoice, 1005, InvoiceEvent.Confirmed));
                     context.MarkDirty();
                 }
             }
@@ -157,7 +156,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, "invoice_completed"));
+                    context.Events.Add(new InvoiceEvent(invoice, 1006, InvoiceEvent.Completed));
                     invoice.Status = InvoiceStatus.Complete;
                     context.MarkDirty();
                 }
@@ -247,13 +246,13 @@ namespace BTCPayServer.HostedServices
             }));
             leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
             {
-                if (b.Name == "invoice_created")
+                if (b.Name == InvoiceEvent.Created)
                 {
                     Watch(b.Invoice.Id);
                     await Wait(b.Invoice.Id);
                 }
 
-                if (b.Name == "invoice_receivedPayment")
+                if (b.Name == InvoiceEvent.ReceivedPayment)
                 {
                     Watch(b.Invoice.Id);
                 }

BTCPayServer/HostedServices/MigratorHostedService.cs

@@ -59,6 +59,18 @@ namespace BTCPayServer.HostedServices
                     settings.ConvertMultiplierToSpread = true;
                     await _Settings.UpdateSetting(settings);
                 }
+                if (!settings.ConvertNetworkFeeProperty)
+                {
+                    await ConvertNetworkFeeProperty();
+                    settings.ConvertNetworkFeeProperty = true;
+                    await _Settings.UpdateSetting(settings);
+                }
+                if (!settings.ConvertCrowdfundOldSettings)
+                {
+                    await ConvertCrowdfundOldSettings();
+                    settings.ConvertCrowdfundOldSettings = true;
+                    await _Settings.UpdateSetting(settings);
+                }
             }
             catch (Exception ex)
             {
@@ -67,6 +79,44 @@ 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())
+            {
+                foreach (var store in await ctx.Stores.ToArrayAsync())
+                {
+                    var blob = store.GetStoreBlob();
+#pragma warning disable CS0618 // Type or member is obsolete
+                    if (blob.NetworkFeeDisabled != null)
+                    {
+                        blob.NetworkFeeMode = blob.NetworkFeeDisabled.Value ? NetworkFeeMode.Never : NetworkFeeMode.Always;
+                        blob.NetworkFeeDisabled = null;
+                        store.SetStoreBlob(blob);
+                    }
+#pragma warning restore CS0618 // Type or member is obsolete
+                }
+                await ctx.SaveChangesAsync();
+            }
+        }
+
         private async Task ConvertMultiplierToSpread()
         {
             using (var ctx = _DBContextFactory.CreateContext())

BTCPayServer/HostedServices/RatesHostedService.cs

@@ -65,9 +65,8 @@ 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)))
             {

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -39,11 +39,13 @@ using BTCPayServer.HostedServices;
 using Meziantou.AspNetCore.BundleTagHelpers;
 using System.Security.Claims;
 using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Security;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 using NBXplorer.DerivationStrategy;
 using NicolasDorier.RateLimits;
 using Npgsql;
+using BTCPayServer.Services.Apps;
 
 namespace BTCPayServer.Hosting
 {
@@ -103,7 +105,46 @@ 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>();
@@ -113,7 +154,7 @@ namespace BTCPayServer.Hosting
             services.TryAddSingleton<CurrencyNameTable>();
             services.TryAddSingleton<IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService<ExplorerClientProvider>())
             {
-                Fallback = new FeeRate(100, 1),
+                Fallback = new FeeRate(100L, 1),
                 BlockTarget = 20
             });
 
@@ -132,6 +173,7 @@ namespace BTCPayServer.Hosting
             services.AddSingleton<IHostedService, HostedServices.CheckConfigurationHostedService>();
 
             services.AddSingleton<Payments.IPaymentMethodHandler<Payments.Lightning.LightningSupportedPaymentMethod>, Payments.Lightning.LightningLikePaymentHandler>();
+            services.AddSingleton<LightningLikePaymentHandler>();
             services.AddSingleton<IHostedService, Payments.Lightning.LightningListener>();
             
             services.AddSingleton<ChangellyClientProvider>();
@@ -140,6 +182,10 @@ namespace BTCPayServer.Hosting
             services.AddSingleton<IHostedService, InvoiceNotificationManager>();
             services.AddSingleton<IHostedService, InvoiceWatcher>();
             services.AddSingleton<IHostedService, RatesHostedService>();
+            services.AddSingleton<IHostedService, BackgroundJobSchedulerHostedService>();
+            services.AddSingleton<IHostedService, AppHubStreamer>();
+
+            services.AddSingleton<IBackgroundJobClient, BackgroundJobClient>();
             services.AddTransient<IConfigureOptions<MvcOptions>, BTCPayClaimsFilter>();
 
             services.TryAddSingleton<ExplorerClientProvider>();
@@ -156,8 +202,9 @@ namespace BTCPayServer.Hosting
             services.TryAddScoped<IHttpContextAccessor, HttpContextAccessor>();
             services.AddTransient<AccessTokenController>();
             services.AddTransient<InvoiceController>();
+            services.AddTransient<AppsPublicController>();
             // Add application services.
-            services.AddTransient<IEmailSender, EmailSender>();
+            services.AddSingleton<EmailSenderFactory>();
             // bundling
 
             services.AddAuthorization(o => Policies.AddBTCPayPolicies(o));

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -38,9 +38,20 @@ namespace BTCPayServer.Hosting
             {
                 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);
@@ -81,32 +92,34 @@ namespace BTCPayServer.Hosting
 
             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";
+
             if (
-                bitpayAuth &&
+                (isCors || bitpayAuth) &&
               (path == "/invoices" || path == "/invoices/") &&
-              httpContext.Request.Method == "POST" &&
-              isJson)
+              (isCors || (method == "POST" && isJson)))
                 return true;
 
             if (
-                bitpayAuth &&
+                (isCors || bitpayAuth) &&
                  (path == "/invoices" || path == "/invoices/") &&
-              httpContext.Request.Method == "GET")
+                 (isCors || method == "GET"))
                 return true;
 
             if (
-                path.StartsWith("/invoices/", StringComparison.OrdinalIgnoreCase) &&
-                httpContext.Request.Method == "GET" &&
-                (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) &&
-                httpContext.Request.Method == "GET")
+                (isCors || method == "GET"))
                 return true;
 
             if (
                 path.Equals("/tokens", StringComparison.Ordinal) &&
-                (httpContext.Request.Method == "GET" || httpContext.Request.Method == "POST"))
+                (isCors || method == "GET" || method == "POST"))
                 return true;
 
             return false;

BTCPayServer/Hosting/Startup.cs

@@ -19,7 +19,6 @@ using BTCPayServer.Models;
 using Microsoft.AspNetCore.Identity;
 using BTCPayServer.Data;
 using Microsoft.Extensions.Logging;
-using Hangfire;
 using BTCPayServer.Logging;
 using Microsoft.AspNetCore.Authorization;
 using System.Threading.Tasks;
@@ -27,11 +26,8 @@ using BTCPayServer.Controllers;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Mails;
 using Microsoft.Extensions.Configuration;
-using Hangfire.AspNetCore;
 using BTCPayServer.Configuration;
 using System.IO;
-using Hangfire.Dashboard;
-using Hangfire.Annotations;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using System.Threading;
 using Microsoft.Extensions.Options;
@@ -40,23 +36,12 @@ using Microsoft.AspNetCore.Server.Kestrel.Core;
 using System.Net;
 using Meziantou.AspNetCore.BundleTagHelpers;
 using BTCPayServer.Security;
+using BTCPayServer.Services.Apps;
 
 namespace BTCPayServer.Hosting
 {
     public class Startup
     {
-        class NeedRole : IDashboardAuthorizationFilter
-        {
-            string _Role;
-            public NeedRole(string role)
-            {
-                _Role = role;
-            }
-            public bool Authorize([NotNull] DashboardContext context)
-            {
-                return context.GetHttpContext().User.IsInRole(_Role);
-            }
-        }
         public Startup(IConfiguration conf, IHostingEnvironment env, ILoggerFactory loggerFactory)
         {
             Configuration = conf;
@@ -78,7 +63,7 @@ namespace BTCPayServer.Hosting
             services.AddIdentity<ApplicationUser, IdentityRole>()
                 .AddEntityFrameworkStores<ApplicationDbContext>()
                 .AddDefaultTokenProviders();
-
+            services.AddSignalR();
             services.AddBTCPayServer();
             services.AddMvc(o =>
             {
@@ -99,7 +84,7 @@ namespace BTCPayServer.Hosting
             services.Configure<IdentityOptions>(options =>
             {
                 options.Password.RequireDigit = false;
-                options.Password.RequiredLength = 7;
+                options.Password.RequiredLength = 6;
                 options.Password.RequireLowercase = false;
                 options.Password.RequireNonAlphanumeric = false;
                 options.Password.RequireUppercase = false;
@@ -107,21 +92,6 @@ namespace BTCPayServer.Hosting
                 options.Lockout.MaxFailedAccessAttempts = 5;
                 options.Lockout.AllowedForNewUsers = true;
             });
-
-            services.AddHangfire((o) =>
-            {
-                var scope = AspNetCoreJobActivator.Current.BeginScope(null);
-                var options = (ApplicationDbContextFactory)scope.Resolve(typeof(ApplicationDbContextFactory));
-                options.ConfigureHangfireBuilder(o);
-            });
-            services.AddCors(o =>
-            {
-                o.AddPolicy("BitpayAPI", b =>
-                {
-                    b.AllowAnyMethod().AllowAnyHeader().AllowAnyOrigin();
-                });
-            });
-
             // If the HTTPS certificate path is not set this logic will NOT be used and the default Kestrel binding logic will be.
             string httpsCertificateFilePath = Configuration.GetOrDefault<string>("HttpsCertificateFilePath", null);
             bool useDefaultCertificate = Configuration.GetOrDefault<bool>("HttpsUseDefaultCertificate", false);
@@ -192,11 +162,9 @@ namespace BTCPayServer.Hosting
             app.UsePayServer();
             app.UseStaticFiles();
             app.UseAuthentication();
-            app.UseHangfireServer();
-            app.UseHangfireDashboard("/hangfire", new DashboardOptions()
+            app.UseSignalR(route =>
             {
-                AppPath = options.GetRootUri(),
-                Authorization = new[] { new NeedRole(Roles.ServerAdmin) }
+                route.MapHub<AppHub>("/apps/hub");
             });
             app.UseWebSockets();
             app.UseStatusCodePages();

BTCPayServer/IDelay.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer
+{
+    public interface IDelay
+    {
+        Task Wait(TimeSpan delay, CancellationToken cancellationToken);
+    }
+
+    public class TaskDelay : IDelay
+    {
+        TaskDelay()
+        {
+
+        }
+        private static readonly TaskDelay _Instance = new TaskDelay();
+        public static TaskDelay Instance
+        {
+            get
+            {
+                return _Instance;
+            }
+        }
+        public Task Wait(TimeSpan delay, CancellationToken cancellationToken)
+        {
+            return Task.Delay(delay, cancellationToken);
+        }
+    }
+}

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");

BTCPayServer/Models/AppViewModels/UpdateCrowdfundViewModel.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Services.Apps;
+
+namespace BTCPayServer.Models.AppViewModels
+{
+    public class UpdateCrowdfundViewModel
+    {
+        [Required] [MaxLength(30)] public string Title { get; set; }
+
+        [MaxLength(50)] public string Tagline { get; set; }
+
+        [Required] public string Description { get; set; }
+        
+        [Display(Name = "Featured Image")]
+        public string MainImageUrl { get; set; }
+
+        public string NotificationUrl { get; set; }
+
+        [Required]
+        [Display(Name = "Allow crowdfund to be publicly visible (still visible to you)")]
+        public bool Enabled { get; set; } = false;
+
+        [Required]
+        [Display(Name = "Enable background animations on new payments")]
+        public bool AnimationsEnabled { get; set; } = true;
+
+        [Required]
+        [Display(Name = "Enable sounds on new payments")]
+        public bool SoundsEnabled { get; set; } = true;
+
+        [Required]
+        [Display(Name = "Enable Disqus Comments")]
+        public bool DisqusEnabled { get; set; } = true;
+
+        [Display(Name = "Disqus Shortname")] public string DisqusShortname { get; set; }
+
+        public DateTime? StartDate { get; set; }
+        public DateTime? EndDate { get; set; }
+
+        [Required]
+        [MaxLength(5)]
+        [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 ")]
+        public decimal? TargetAmount { get; set; }
+
+
+        public IEnumerable<string> ResetEveryValues = Enum.GetNames(typeof(CrowdfundResetEvery));
+
+        [Display(Name = "Reset goal every")] public string ResetEvery { get; set; } = nameof(CrowdfundResetEvery.Never);
+
+        public int ResetEveryAmount { get; set; } = 1;
+
+
+        [Display(Name = "Do not allow additional contributions after target has been reached")]
+        public bool EnforceTargetAmount { get; set; }
+
+        [Display(Name = "Contribution Perks Template")]
+        public string PerksTemplate { 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 = "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; }
+    }
+}

BTCPayServer/Models/AppViewModels/UpdatePointOfSaleViewModel.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations;
-using System.Linq;
-using System.Threading.Tasks;
+using System.ComponentModel.DataAnnotations;
 
 namespace BTCPayServer.Models.AppViewModels
 {
@@ -36,11 +32,16 @@ namespace BTCPayServer.Models.AppViewModels
         public string CustomButtonText { get; set; }
         [Required]
         [MaxLength(30)]
-        [Display(Name = "Do you want to leave a tip?")]
+        [Display(Name = "Text to display in the tip input")]
         public string CustomTipText { get; set; }
+        [MaxLength(30)]
+        [Display(Name = "Tip percentage amounts (comma separated)")]
+        public string CustomTipPercentages { get; set; }
 
         [MaxLength(500)]
         [Display(Name = "Custom bootstrap CSS file")]
         public string CustomCSSLink { get; set; }
+
+        public string Id { get; set; }
     }
 }

BTCPayServer/Models/AppViewModels/ViewCrowdfundViewModel.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+
+namespace BTCPayServer.Models.AppViewModels
+{
+    public class ViewCrowdfundViewModel
+    {
+        public string StatusMessage{ get; set; }
+        public string StoreId { get; set; }
+        public string AppId { get; set; }
+        public string Title { get; set; }
+        public string Description { get; set; }
+        public string MainImageUrl { get; set; }
+        public string EmbeddedCSS { get; set; }
+        public string CustomCSSLink { get; set; }
+        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 CrowdfundInfo Info { get; set; }
+        public string Tagline { get; set; }
+        public ViewPointOfSaleViewModel.Item[] Perks { get; set; }
+        public bool DisqusEnabled { get; set; }
+        public bool SoundsEnabled { get; set; }
+        public string DisqusShortname { get; set; }
+        public bool AnimationsEnabled { get; set; }
+        public int ResetEveryAmount { get; set; }
+        public bool NeverReset { get; set; }
+
+        public Dictionary<string, int> PerkCount { get; set; }
+
+        public CurrencyData CurrencyData { get; set; }
+        
+        public class CrowdfundInfo
+        {
+            public int TotalContributors { get; set; }
+            public decimal CurrentPendingAmount { get; set; }
+            public decimal CurrentAmount { get; set; }
+            public decimal? ProgressPercentage { get; set; }
+            public decimal? PendingProgressPercentage { get; set; }
+            public DateTime LastUpdated { get; set; }
+            public Dictionary<string, decimal> PaymentStats { get; set; }
+            public Dictionary<string, decimal> PendingPaymentStats { get; set; }
+            public DateTime? LastResetDate { get; set; }
+            public DateTime? NextResetDate { get; set; }
+        }
+
+        public bool Started => !StartDate.HasValue || DateTime.Now.ToUniversalTime() > StartDate;
+
+        public bool Ended => !EndDate.HasValue || DateTime.Now.ToUniversalTime() > EndDate;
+        public bool DisplayPerksRanking { get; set; }
+    }
+
+    public class ContributeToCrowdfund
+    {
+        public ViewCrowdfundViewModel ViewCrowdfundViewModel { get; set; }
+        [Required] public decimal Amount { get; set; }
+        public string Email { get; set; }
+        public string ChoiceKey { get; set; }
+        public bool RedirectToCheckout { get; set; }
+        public string RedirectUrl { get; set; }
+    }
+}

BTCPayServer/Models/AppViewModels/ViewPointOfSaleViewModel.cs

@@ -45,6 +45,7 @@ namespace BTCPayServer.Models.AppViewModels
         public string ButtonText { get; set; }
         public string CustomButtonText { get; set; }
         public string CustomTipText { get; set; }
+        public int[] CustomTipPercentages { get; set; }
 
         public string CustomCSSLink { 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,83 @@
+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; }
+    }
+}

BTCPayServer/Models/InvoiceResponse.cs

@@ -40,6 +40,12 @@ namespace BTCPayServer.Models
     //{"facade":"pos/invoice","data":{,}}
     public class InvoiceResponse
     {
+        [JsonIgnore]
+        public string StoreId
+        {
+            get; set;
+        }
+        
         //"url":"https://test.bitpay.com/invoice?id=9saCHtp1zyPcNoi3rDdBu8"
         [JsonProperty("url")]
         public string Url
@@ -84,6 +90,12 @@ namespace BTCPayServer.Models
             get; set;
         }
 
+        [JsonProperty("taxIncluded", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public decimal TaxIncluded
+        {
+            get; set;
+        }
+
         //"currency":"USD"
         [JsonProperty("currency")]
         public string Currency

BTCPayServer/Models/InvoicingModels/InvoiceDetailsModel.cs

@@ -105,6 +105,7 @@ namespace BTCPayServer.Models.InvoicingModels
             get;
             set;
         }
+        public string TaxIncluded { get; set; }
         public BuyerInformation BuyerInformation
         {
             get;
@@ -143,6 +144,6 @@ namespace BTCPayServer.Models.InvoicingModels
         public DateTimeOffset MonitoringDate { get; internal set; }
         public List<Data.InvoiceEventData> Events { get; internal set; }
         public string NotificationEmail { get; internal set; }
-        public Dictionary<string, string> PosData { get; set; }
+        public Dictionary<string, object> PosData { get; set; }
     }
 }

BTCPayServer/Models/InvoicingModels/InvoicesModel.cs

@@ -15,6 +15,10 @@ namespace BTCPayServer.Models.InvoicingModels
         {
             get; set;
         }
+        public int Total
+        {
+            get; set;
+        }
         public string SearchTerm
         {
             get; set;

BTCPayServer/Models/InvoicingModels/PaymentModel.cs

@@ -24,7 +24,6 @@ namespace BTCPayServer.Models.InvoicingModels
         public bool IsModal { get; set; }
         public bool IsLightning { get; set; }
         public string CryptoCode { get; set; }
-        public string ServerUrl { get; set; }
         public string InvoiceId { get; set; }
         public string BtcAddress { get; set; }
         public string BtcDue { get; set; }
@@ -61,5 +60,9 @@ namespace BTCPayServer.Models.InvoicingModels
         public string PeerInfo { get; set; }
         public string ChangellyMerchantId { get; set; }
         public decimal? ChangellyAmountDue { get; set; }
+        
+        public bool CoinSwitchEnabled { get; set; }
+        public string CoinSwitchMode { get; set; }
+        public string CoinSwitchMerchantId { 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/StatusMessageModel.cs

@@ -0,0 +1,80 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Models
+{
+    public class StatusMessageModel
+    {
+        public StatusMessageModel()
+        {
+        }
+
+        public StatusMessageModel(string s)
+        {
+            if (string.IsNullOrEmpty(s))
+                return;
+            try
+            {
+                if (s.StartsWith("{", StringComparison.InvariantCultureIgnoreCase) &&
+                    s.EndsWith("}", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    var model = JObject.Parse(s).ToObject<StatusMessageModel>();
+                    Html = model.Html;
+                    Message = model.Message;
+                    Severity = model.Severity;
+                }
+                else
+                {
+                    ParseNonJsonStatus(s);
+                }
+            }
+            catch (Exception)
+            {
+                ParseNonJsonStatus(s);
+            }
+        }
+
+        public string Message { get; set; }
+        public string Html { get; set; }
+        public StatusSeverity Severity { get; set; }
+
+        public string SeverityCSS
+        {
+            get
+            {
+                switch (Severity)
+                {
+                    case StatusSeverity.Info:
+                        return "info";
+                    case StatusSeverity.Error:
+                        return "danger";
+                    case StatusSeverity.Success:
+                        return "success";
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            return JObject.FromObject(this).ToString(Formatting.None);
+        }
+        
+        private void ParseNonJsonStatus(string s)
+        {
+            Message = s;
+            Severity = s.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase)
+                ? StatusSeverity.Error
+                : StatusSeverity.Success;
+        }
+
+        public enum StatusSeverity
+        {
+            Info,
+            Error,
+            Success
+        }
+    }
+}

BTCPayServer/Models/StoreViewModels/CheckoutExperienceViewModel.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Payments;
 using BTCPayServer.Services;
 using BTCPayServer.Validation;
 using Microsoft.AspNetCore.Mvc.Rendering;
@@ -11,16 +12,17 @@ namespace BTCPayServer.Models.StoreViewModels
 {
     public class CheckoutExperienceViewModel
     {
-        class Format
+        public class Format
         {
             public string Name { get; set; }
             public string Value { get; set; }
+            public PaymentMethodId PaymentId { get; set; }
         }
         public SelectList CryptoCurrencies { get; set; }
         public SelectList Languages { get; set; }
 
-        [Display(Name = "Default crypto currency on checkout")]
-        public string DefaultCryptoCurrency { get; set; }
+        [Display(Name = "Default the 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...")]
@@ -47,15 +49,6 @@ namespace BTCPayServer.Models.StoreViewModels
         [Display(Name = "Custom HTML title to display on Checkout page")]
         public string HtmlTitle { get; set; }
 
-
-        public void SetCryptoCurrencies(ExplorerClientProvider explorerProvider, string defaultCrypto)
-        {
-            var choices = explorerProvider.GetAll().Select(o => new Format() { Name = o.Item1.CryptoCode, Value = o.Item1.CryptoCode }).ToArray();
-            var chosen = choices.FirstOrDefault(f => f.Value == defaultCrypto) ?? choices.FirstOrDefault();
-            CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
-            DefaultCryptoCurrency = chosen.Name;
-        }
-
         public void SetLanguages(LanguageService langService, string defaultLang)
         {
             defaultLang = langService.GetLanguages().Any(language => language.Code == defaultLang)? defaultLang : "en";

BTCPayServer/Models/StoreViewModels/DerivationSchemeViewModel.cs

@@ -24,6 +24,7 @@ namespace BTCPayServer.Models.StoreViewModels
         } = new List<(string KeyPath, string Address)>();
 
         public string CryptoCode { get; set; }
+        public string KeyPath { get; set; }
         [Display(Name = "Hint address")]
         public string HintAddress { get; set; }
         public bool Confirmation { get; set; }

BTCPayServer/Models/StoreViewModels/LightningNodeViewModel.cs

@@ -25,5 +25,7 @@ namespace BTCPayServer.Models.StoreViewModels
         public string InternalLightningNode { get; internal set; }
         public bool SkipPortTest { get; set; }
         public bool Enabled { get; set; } = true;
+
+        public string StoreId { get; set; }
     }
 }

BTCPayServer/Models/StoreViewModels/StoreViewModel.cs

@@ -82,8 +82,8 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         }
 
-        [Display(Name = "Add network fee to invoice (vary with mining fees)")]
-        public bool NetworkFee
+        [Display(Name = "Add additional fee (network fee) to invoice...")]
+        public Data.NetworkFeeMode NetworkFeeMode
         {
             get; set;
         }

BTCPayServer/Models/StoreViewModels/TokensViewModel.cs

@@ -72,5 +72,6 @@ namespace BTCPayServer.Models.StoreViewModels
         [Display(Name = "API Key")]
         public string ApiKey { get; set; }
         public string EncodedApiKey { get; set; }
+        public bool StoreNotConfigured { get; set; }
     }
 }

BTCPayServer/Models/StoreViewModels/UpdateCoinSwitchSettingsViewModel.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Payments.CoinSwitch;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.StoreViewModels
+{
+    public class UpdateCoinSwitchSettingsViewModel
+    {
+        public string MerchantId { get; set; }
+        public bool Enabled { get; set; }
+
+        [Display(Name = "Integration Mode")]
+        public string Mode { get; set; } = "inline";
+
+        public List<SelectListItem> Modes { get; } = new List<SelectListItem>
+        {
+            new SelectListItem { Value = "popup", Text = "Open in a popup" },
+            new SelectListItem { Value = "inline", Text = "Embed inside Checkout UI " },
+        };
+        
+        public string StatusMessage { get; set; }
+    }
+}

BTCPayServer/Models/WalletViewModels/WalletSendLedgerModel.cs

@@ -11,5 +11,6 @@ namespace BTCPayServer.Models.WalletViewModels
         public bool SubstractFees { get; set; }
         public decimal Amount { get; set; }
         public string Destination { get; set; }
+        public bool NoChange { get; set; }
     }
 }

BTCPayServer/Models/WalletViewModels/WalletSendModel.cs

@@ -28,6 +28,10 @@ namespace BTCPayServer.Models.WalletViewModels
         [Display(Name = "Fee rate (satoshi per byte)")]
         [Required]
         public int FeeSatoshiPerByte { get; set; }
+
+        [Display(Name = "Make sure no change UTXO is created")]
+        public bool NoChange { get; set; }
+        public bool AdvancedMode { get; set; }
         public decimal? Rate { get; set; }
         public int Divisibility { get; set; }
         public string Fiat { get; set; }

BTCPayServer/Payments/Bitcoin/BitcoinLikeOnChainPaymentMethod.cs

@@ -20,27 +20,21 @@ namespace BTCPayServer.Payments.Bitcoin
             return DepositAddress;
         }
 
-        public decimal GetTxFee()
+        public decimal GetNextNetworkFee()
         {
-            return TxFee.ToDecimal(MoneyUnit.BTC);
+            return NextNetworkFee.ToDecimal(MoneyUnit.BTC);
         }
-
-        public void SetNoTxFee()
-        {
-            TxFee = Money.Zero;
-        }
-
-
         public void SetPaymentDestination(string newPaymentDestination)
         {
             DepositAddress = newPaymentDestination;
         }
+        public Data.NetworkFeeMode NetworkFeeMode { get; set; }
 
         // Those properties are JsonIgnore because their data is inside CryptoData class for legacy reason
         [JsonIgnore]
         public FeeRate FeeRate { get; set; }
         [JsonIgnore]
-        public Money TxFee { get; set; }
+        public Money NextNetworkFee { get; set; }
         [JsonIgnore]
         public String DepositAddress { get; set; }
         public BitcoinAddress GetDepositAddress(Network network)

BTCPayServer/Payments/Bitcoin/BitcoinLikePaymentData.cs

@@ -32,6 +32,7 @@ namespace BTCPayServer.Payments.Bitcoin
         public TxOut Output { get; set; }
         public int ConfirmationCount { get; set; }
         public bool RBF { get; set; }
+        public decimal NetworkFee { get; set; }
 
         /// <summary>
         /// This is set to true if the payment was created before CryptoPaymentData existed in BTCPayServer

BTCPayServer/Payments/Bitcoin/BitcoinLikePaymentHandler.cs

@@ -48,8 +48,18 @@ namespace BTCPayServer.Payments.Bitcoin
                 throw new PaymentMethodUnavailableException($"Full node not available");
             var prepare = (Prepare)preparePaymentObject;
             Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod onchainMethod = new Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod();
+            onchainMethod.NetworkFeeMode = store.GetStoreBlob().NetworkFeeMode;
             onchainMethod.FeeRate = await prepare.GetFeeRate;
-            onchainMethod.TxFee = onchainMethod.FeeRate.GetFee(100); // assume price for 100 bytes
+            switch (onchainMethod.NetworkFeeMode)
+            {
+                case NetworkFeeMode.Always:
+                    onchainMethod.NextNetworkFee = onchainMethod.FeeRate.GetFee(100); // assume price for 100 bytes
+                    break;
+                case NetworkFeeMode.Never:
+                case NetworkFeeMode.MultiplePaymentsOnly:
+                    onchainMethod.NextNetworkFee = Money.Zero;
+                    break;
+            }
             onchainMethod.DepositAddress = (await prepare.ReserveAddress).ToString();
             return onchainMethod;
         }

BTCPayServer/Payments/Bitcoin/NBXplorerListener.cs

@@ -33,12 +33,10 @@ namespace BTCPayServer.Payments.Bitcoin
         private TaskCompletionSource<bool> _RunningTask;
         private CancellationTokenSource _Cts;
         BTCPayWalletProvider _Wallets;
-        BTCPayNetworkProvider _NetworkProvider;
 
         public NBXplorerListener(ExplorerClientProvider explorerClients,
                                 BTCPayWalletProvider wallets,
                                 InvoiceRepository invoiceRepository,
-                                BTCPayNetworkProvider networkProvider,
                                 EventAggregator aggregator, Microsoft.Extensions.Hosting.IApplicationLifetime lifetime)
         {
             PollInterval = TimeSpan.FromMinutes(1.0);
@@ -47,7 +45,6 @@ namespace BTCPayServer.Payments.Bitcoin
             _ExplorerClients = explorerClients;
             _Aggregator = aggregator;
             _Lifetime = lifetime;
-            _NetworkProvider = networkProvider;
         }
 
         CompositeDisposable leases = new CompositeDisposable();
@@ -158,7 +155,7 @@ namespace BTCPayServer.Payments.Bitcoin
                                             var alreadyExist = GetAllBitcoinPaymentData(invoice).Where(c => c.GetPaymentId() == paymentData.GetPaymentId()).Any();
                                             if (!alreadyExist)
                                             {
-                                                var payment = await _InvoiceRepository.AddPayment(invoice.Id, DateTimeOffset.UtcNow, paymentData, network.CryptoCode);
+                                                var payment = await _InvoiceRepository.AddPayment(invoice.Id, DateTimeOffset.UtcNow, paymentData, network);
                                                 if(payment != null)
                                                     await ReceivedPayment(wallet, invoice, payment, evt.DerivationStrategy);
                                             }
@@ -332,7 +329,7 @@ namespace BTCPayServer.Payments.Bitcoin
                 {
                     var transaction = await wallet.GetTransactionAsync(coin.Coin.Outpoint.Hash);
                     var paymentData = new BitcoinLikePaymentData(coin.Coin, transaction.Transaction.RBF);
-                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.Timestamp, paymentData, network.CryptoCode).ConfigureAwait(false);
+                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.Timestamp, paymentData, network).ConfigureAwait(false);
                     alreadyAccounted.Add(coin.Coin.Outpoint);
                     if (payment != null)
                     {
@@ -373,7 +370,7 @@ namespace BTCPayServer.Payments.Bitcoin
                 invoice.SetPaymentMethod(paymentMethod);
             }
             wallet.InvalidateCache(strategy);
-            _Aggregator.Publish(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1002, "invoice_receivedPayment"));
+            _Aggregator.Publish(new InvoiceEvent(invoice, 1002, InvoiceEvent.ReceivedPayment){Payment = payment});
             return invoice;
         }
         public Task StopAsync(CancellationToken cancellationToken)

BTCPayServer/Payments/Coinswitch/CoinswitchSettings.cs

@@ -0,0 +1,15 @@
+namespace BTCPayServer.Payments.CoinSwitch
+{
+    public class CoinSwitchSettings
+    {
+        public string MerchantId { get; set; }
+        public string Mode { get; set; }
+        public bool Enabled { get; set; }
+        
+        public bool IsConfigured()
+        {
+            return
+                !string.IsNullOrEmpty(MerchantId);
+        }
+    }
+}

BTCPayServer/Payments/IPaymentFilter.cs

@@ -12,6 +12,21 @@ namespace BTCPayServer.Payments
 
     public class PaymentFilter
     {
+        class OrPaymentFilter : IPaymentFilter
+        {
+            private readonly IPaymentFilter _a;
+            private readonly IPaymentFilter _b;
+
+            public OrPaymentFilter(IPaymentFilter a, IPaymentFilter b)
+            {
+                _a = a;
+                _b = b;
+            }
+            public bool Match(PaymentMethodId paymentMethodId)
+            {
+                return _a.Match(paymentMethodId) || _b.Match(paymentMethodId);
+            }
+        }
         class NeverPaymentFilter : IPaymentFilter
         {
 
@@ -54,6 +69,34 @@ namespace BTCPayServer.Payments
                 return paymentMethodId == _paymentMethodId;
             }
         }
+        class PredicateFilter : IPaymentFilter
+        {
+            private Func<PaymentMethodId, bool> predicate;
+
+            public PredicateFilter(Func<PaymentMethodId, bool> predicate)
+            {
+                this.predicate = predicate;
+            }
+
+            public bool Match(PaymentMethodId paymentMethodId)
+            {
+                return this.predicate(paymentMethodId);
+            }
+        }
+        public static IPaymentFilter Where(Func<PaymentMethodId, bool> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException(nameof(predicate));
+            return new PredicateFilter(predicate);
+        }
+        public static IPaymentFilter Or(IPaymentFilter a, IPaymentFilter b)
+        {
+            if (a == null)
+                throw new ArgumentNullException(nameof(a));
+            if (b == null)
+                throw new ArgumentNullException(nameof(b));
+            return new OrPaymentFilter(a, b);
+        }
         public static IPaymentFilter Never()
         {
             return NeverPaymentFilter.Instance;

BTCPayServer/Payments/IPaymentMethodDetails.cs

@@ -18,11 +18,10 @@ namespace BTCPayServer.Payments
         string GetPaymentDestination();
         PaymentTypes GetPaymentType();
         /// <summary>
-        /// Returns what a merchant would need to pay to cashout this payment
+        /// Returns fee that the merchant charge to the customer for the next payment
         /// </summary>
         /// <returns></returns>
-        decimal GetTxFee();
-        void SetNoTxFee();
+        decimal GetNextNetworkFee();
         /// <summary>
         /// Change the payment destination (internal plumbing)
         /// </summary>

BTCPayServer/Payments/Lightning/LightningLikePaymentData.cs

@@ -7,6 +7,7 @@ using BTCPayServer.Lightning;
 using BTCPayServer.Lightning.JsonConverters;
 using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Services.Invoices;
+using NBitcoin;
 using Newtonsoft.Json;
 
 namespace BTCPayServer.Payments.Lightning
@@ -16,15 +17,21 @@ namespace BTCPayServer.Payments.Lightning
         [JsonConverter(typeof(LightMoneyJsonConverter))]
         public LightMoney Amount { get; set; }
         public string BOLT11 { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.UInt256JsonConverter))]
+        public uint256 PaymentHash { get; set; }
 
         public string GetDestination(BTCPayNetwork network)
         {
-            return GetPaymentId();
+            return BOLT11;
         }
 
+        public decimal NetworkFee { get; set; }
+
+
         public string GetPaymentId()
         {
-            return BOLT11;
+            // Legacy, some old payments don't have the PaymentHash set
+            return PaymentHash?.ToString() ?? BOLT11;
         }
 
         public PaymentTypes GetPaymentType()

BTCPayServer/Payments/Lightning/LightningLikePaymentHandler.cs

@@ -25,7 +25,7 @@ namespace BTCPayServer.Payments.Lightning
         public override async Task<IPaymentMethodDetails> CreatePaymentMethodDetails(LightningSupportedPaymentMethod supportedPaymentMethod, PaymentMethod paymentMethod, StoreData store, BTCPayNetwork network, object preparePaymentObject)
         {
             var storeBlob = store.GetStoreBlob();
-            var test = Test(supportedPaymentMethod, network);
+            var test = GetNodeInfo(supportedPaymentMethod, network);
             var invoice = paymentMethod.ParentEntity;
             var due = Extensions.RoundUp(invoice.ProductInformation.Price / paymentMethod.Rate, 8);
             var client = supportedPaymentMethod.CreateClient(network);
@@ -47,7 +47,7 @@ namespace BTCPayServer.Payments.Lightning
                 }
                 catch (OperationCanceledException) when (cts.IsCancellationRequested)
                 {
-                    throw new PaymentMethodUnavailableException($"The lightning node did not replied in a timely maner");
+                    throw new PaymentMethodUnavailableException($"The lightning node did not reply in a timely maner");
                 }
                 catch (Exception ex)
                 {
@@ -63,7 +63,7 @@ namespace BTCPayServer.Payments.Lightning
             };
         }
 
-        public async Task<NodeInfo> Test(LightningSupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
+        public async Task<NodeInfo> GetNodeInfo(LightningSupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
         {
             if (!_Dashboard.IsFullySynched(network.CryptoCode, out var summary))
                 throw new PaymentMethodUnavailableException($"Full node not available");
@@ -78,7 +78,7 @@ namespace BTCPayServer.Payments.Lightning
                 }
                 catch (OperationCanceledException) when (cts.IsCancellationRequested)
                 {
-                    throw new PaymentMethodUnavailableException($"The lightning node did not replied in a timely maner");
+                    throw new PaymentMethodUnavailableException($"The lightning node did not reply in a timely manner");
                 }
                 catch (Exception ex)
                 {
@@ -115,7 +115,7 @@ namespace BTCPayServer.Payments.Lightning
                 }
 
                 if (address == null)
-                    throw new PaymentMethodUnavailableException($"DNS did not resolved {nodeInfo.Host}");
+                    throw new PaymentMethodUnavailableException($"DNS did not resolve {nodeInfo.Host}");
 
                 using (var tcp = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
                 {

BTCPayServer/Payments/Lightning/LightningLikePaymentMethodDetails.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using NBitcoin;
 
 namespace BTCPayServer.Payments.Lightning
 {
@@ -21,15 +22,10 @@ namespace BTCPayServer.Payments.Lightning
             return PaymentTypes.LightningLike;
         }
 
-        public decimal GetTxFee()
+        public decimal GetNextNetworkFee()
         {
             return 0.0m;
         }
-
-        public void SetNoTxFee()
-        {
-        }
-
         public void SetPaymentDestination(string newPaymentDestination)
         {
             BOLT11 = newPaymentDestination;

BTCPayServer/Payments/Lightning/LightningListener.cs

@@ -42,7 +42,7 @@ namespace BTCPayServer.Payments.Lightning
         {
             leases.Add(_Aggregator.Subscribe<Events.InvoiceEvent>(async inv =>
             {
-                if (inv.Name == "invoice_created")
+                if (inv.Name == InvoiceEvent.Created)
                 {
                     await EnsureListening(inv.Invoice.Id, false);
                 }
@@ -191,13 +191,14 @@ namespace BTCPayServer.Payments.Lightning
             var payment = await _InvoiceRepository.AddPayment(listenedInvoice.InvoiceId, notification.PaidAt.Value, new LightningLikePaymentData()
             {
                 BOLT11 = notification.BOLT11,
+                PaymentHash = BOLT11PaymentRequest.Parse(notification.BOLT11, network.NBitcoinNetwork).PaymentHash,
                 Amount = notification.Amount
-            }, network.CryptoCode, accounted: true);
+            }, network, accounted: true);
             if (payment != null)
             {
                 var invoice = await _InvoiceRepository.GetInvoice(listenedInvoice.InvoiceId);
                 if (invoice != null)
-                    _Aggregator.Publish(new InvoiceEvent(invoice.EntityToDTO(_NetworkProvider), 1002, "invoice_receivedPayment"));
+                    _Aggregator.Publish(new InvoiceEvent(invoice, 1002, InvoiceEvent.ReceivedPayment){Payment = payment});
             }
         }
 

BTCPayServer/Payments/PaymentMethodId.cs

@@ -67,10 +67,37 @@ namespace BTCPayServer.Payments
             return CryptoCode + "_" + PaymentType.ToString();
         }
 
+        public static bool TryParse(string str, out PaymentMethodId paymentMethodId)
+        {
+            paymentMethodId = null;
+            var parts = str.Split('_', StringSplitOptions.RemoveEmptyEntries);
+            if (parts.Length == 0 || parts.Length > 2)
+                return false;
+            PaymentTypes type = PaymentTypes.BTCLike;
+            if (parts.Length == 2)
+            {
+                switch (parts[1].ToLowerInvariant())
+                {
+                    case "btclike":
+                    case "onchain":
+                        type = PaymentTypes.BTCLike;
+                        break;
+                    case "lightninglike":
+                    case "offchain":
+                        type = PaymentTypes.LightningLike;
+                        break;
+                    default:
+                        return false;
+                }
+            }
+            paymentMethodId = new PaymentMethodId(parts[0], type);
+            return true;
+        }
         public static PaymentMethodId Parse(string str)
         {
-            var parts = str.Split('_');
-            return new PaymentMethodId(parts[0], parts.Length == 1 ? PaymentTypes.BTCLike : Enum.Parse<PaymentTypes>(parts[1]));
+            if (!TryParse(str, out var result))
+                throw new FormatException("Invalid PaymentMethodId");
+            return result;
         }
     }
 }

BTCPayServer/Properties/launchSettings.json

@@ -11,6 +11,7 @@
                 "BTCPAY_BTCEXTERNALLNDGRPC": "type=lnd-grpc;server=https://lnd:lnd@127.0.0.1:53280/;allowinsecure=true",
                 "BTCPAY_BTCEXTERNALLNDREST": "type=lnd-rest;server=https://lnd:lnd@127.0.0.1:53280/lnd-rest/btc/;allowinsecure=true;macaroonfilepath=D:\\admin.macaroon",
                 "BTCPAY_BTCEXPLORERURL": "http://127.0.0.1:32838/",
+                "BTCPAY_DISABLE-REGISTRATION": "false",
                 "ASPNETCORE_ENVIRONMENT": "Development",
                 "BTCPAY_CHAINS": "btc,ltc",
                 "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"
@@ -32,6 +33,7 @@
                 "BTCPAY_BTCEXTERNALSPARK": "server=https://127.0.0.1:53280/spark/btc/;cookiefile=fake",
                 "BTCPAY_BTCEXTERNALCHARGE": "server=https://127.0.0.1:53280/spark/btc/;cookiefilepath=fake",
                 "BTCPAY_BTCEXPLORERURL": "http://127.0.0.1:32838/",
+                "BTCPAY_DISABLE-REGISTRATION": "false",
                 "ASPNETCORE_ENVIRONMENT": "Development",
                 "BTCPAY_CHAINS": "btc,ltc",
                 "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver",

BTCPayServer/Security/BitpayAuthentication.cs

@@ -198,44 +198,6 @@ namespace BTCPayServer.Security
                 }
                 yield return token;
             }
-
-            private bool IsBitpayAPI(HttpContext httpContext, bool bitpayAuth)
-            {
-                if (!httpContext.Request.Path.HasValue)
-                    return false;
-
-                var isJson = (httpContext.Request.ContentType ?? string.Empty).StartsWith("application/json", StringComparison.OrdinalIgnoreCase);
-                var path = httpContext.Request.Path.Value;
-                if (
-                    bitpayAuth &&
-                    (path == "/invoices" || path == "/invoices/") &&
-                  httpContext.Request.Method == "POST" &&
-                  isJson)
-                    return true;
-
-                if (
-                    bitpayAuth &&
-                    (path == "/invoices" || path == "/invoices/") &&
-                  httpContext.Request.Method == "GET")
-                    return true;
-
-                if (
-                    path.StartsWith("/invoices/", StringComparison.OrdinalIgnoreCase) &&
-                    httpContext.Request.Method == "GET" &&
-                    (isJson || httpContext.Request.Query.ContainsKey("token")))
-                    return true;
-
-                if (path.Equals("/rates", StringComparison.OrdinalIgnoreCase) &&
-                    httpContext.Request.Method == "GET")
-                    return true;
-
-                if (
-                    path.Equals("/tokens", StringComparison.Ordinal) &&
-                    (httpContext.Request.Method == "GET" || httpContext.Request.Method == "POST"))
-                    return true;
-
-                return false;
-            }
         }
         internal static void AddAuthentication(IServiceCollection services, Action<BitpayAuthOptions> bitpayAuth = null)
         {

BTCPayServer/Services/Apps/AppHub.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Models.AppViewModels;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BTCPayServer.Services.Apps
+{
+    public class AppHub: Hub
+    {
+        public const string InvoiceCreated = "InvoiceCreated";
+        public const string PaymentReceived = "PaymentReceived";
+        public const string InfoUpdated = "InfoUpdated";
+        public const string InvoiceError = "InvoiceError";
+        private readonly AppsPublicController _AppsPublicController;
+
+        public AppHub(AppsPublicController appsPublicController)
+        {
+            _AppsPublicController = appsPublicController;
+        }
+        public async Task ListenToCrowdfundApp(string appId)
+        {
+            if (Context.Items.ContainsKey("app"))
+            {
+                await Groups.RemoveFromGroupAsync(Context.ConnectionId, Context.Items["app"].ToString());
+                Context.Items.Remove("app");
+            }
+            Context.Items.Add("app", appId);
+            await Groups.AddToGroupAsync(Context.ConnectionId, appId);
+        }
+
+
+        public async Task CreateInvoice(ContributeToCrowdfund model)
+        {
+               model.RedirectToCheckout = false;
+               _AppsPublicController.ControllerContext.HttpContext = Context.GetHttpContext();
+               try
+               {
+
+                   var result =
+                       await _AppsPublicController.ContributeToCrowdfund(Context.Items["app"].ToString(), model);
+                   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;
+                   }
+               }
+               catch (Exception)
+               {
+                   await Clients.Caller.SendCoreAsync(InvoiceError, System.Array.Empty<object>());
+
+               }
+
+        }
+
+    }
+}

BTCPayServer/Services/Apps/AppHubStreamer.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Logging;
+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.Hosting;
+using Microsoft.Extensions.Logging;
+using NBitcoin;
+
+namespace BTCPayServer.Services.Apps
+{
+    public class AppHubStreamer : EventHostedServiceBase
+    {
+        private readonly AppService _appService;
+        private IHubContext<AppHub> _HubContext;
+
+        public AppHubStreamer(EventAggregator eventAggregator,
+           IHubContext<AppHub> hubContext,
+           AppService appService) : base(eventAggregator)
+        {
+            _appService = appService;
+            _HubContext = hubContext;
+        }
+
+        protected override void SubscibeToEvents()
+        {
+            Subscribe<InvoiceEvent>();
+            Subscribe<AppsController.AppUpdated>();
+        }
+
+        protected override  async Task ProcessEvent(object evt, CancellationToken cancellationToken)
+        {
+            if (evt is InvoiceEvent invoiceEvent)
+            {
+                foreach (var appId in AppService.GetAppInternalTags(invoiceEvent.Invoice.InternalTags))
+                {
+                    if (invoiceEvent.Name == InvoiceEvent.ReceivedPayment)
+                    {
+                        var data = invoiceEvent.Payment.GetCryptoPaymentData();
+                        await _HubContext.Clients.Group(appId).SendCoreAsync(AppHub.PaymentReceived, new object[]
+                            {
+                        data.GetValue(),
+                        invoiceEvent.Payment.GetCryptoCode(),
+                        Enum.GetName(typeof(PaymentTypes),
+                            invoiceEvent.Payment.GetPaymentMethodId().PaymentType)
+                            }, cancellationToken);
+                    }
+                    await InfoUpdated(appId);
+                }
+            }
+            else if (evt is AppsController.AppUpdated app)
+            {
+                await InfoUpdated(app.AppId);
+            }
+        }
+
+        private async Task InfoUpdated(string appId)
+        {
+            var info = await _appService.GetAppInfo(appId);
+            await _HubContext.Clients.Group(appId).SendCoreAsync(AppHub.InfoUpdated, new object[] { info });
+        }
+    }
+}

BTCPayServer/Services/Apps/AppService.cs

@@ -0,0 +1,400 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Filters;
+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.Cors;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using NBitpayClient;
+using YamlDotNet.RepresentationModel;
+using static BTCPayServer.Controllers.AppsController;
+
+namespace BTCPayServer.Services.Apps
+{
+    public class AppService
+    {
+        ApplicationDbContextFactory _ContextFactory;
+        private readonly InvoiceRepository _InvoiceRepository;
+        CurrencyNameTable _Currencies;
+        private readonly RateFetcher _RateFetcher;
+        private readonly HtmlSanitizer _HtmlSanitizer;
+        private readonly BTCPayNetworkProvider _Networks;
+        public CurrencyNameTable Currencies => _Currencies;
+        public AppService(ApplicationDbContextFactory contextFactory,
+                          InvoiceRepository invoiceRepository,
+                          BTCPayNetworkProvider networks,
+                          CurrencyNameTable currencies,
+                          RateFetcher rateFetcher,
+                          HtmlSanitizer htmlSanitizer)
+        {
+            _ContextFactory = contextFactory;
+            _InvoiceRepository = invoiceRepository;
+            _Currencies = currencies;
+            _RateFetcher = rateFetcher;
+            _HtmlSanitizer = htmlSanitizer;
+            _Networks = networks;
+        }
+
+        public async Task<object> GetAppInfo(string appId)
+        {
+            var app = await GetApp(appId, AppType.Crowdfund, true);
+            return await GetInfo(app);
+        }
+        private async Task<ViewCrowdfundViewModel> GetInfo(AppData appData, string statusMessage = null)
+        {
+            var settings = appData.GetSettings<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(appData, lastResetDate);
+            var completeInvoices = invoices.Where(entity => entity.Status == InvoiceStatus.Complete || entity.Status == InvoiceStatus.Confirmed).ToArray();
+            var pendingInvoices = invoices.Where(entity => !(entity.Status == InvoiceStatus.Complete || entity.Status == InvoiceStatus.Confirmed)).ToArray();
+
+            var rateRules = appData.StoreData.GetStoreBlob().GetRateRules(_Networks);
+
+            var pendingPaymentStats = GetCurrentContributionAmountStats(pendingInvoices, !settings.EnforceTargetAmount);
+            var paymentStats = GetCurrentContributionAmountStats(completeInvoices, !settings.EnforceTargetAmount);
+
+            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 = 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,
+                NeverReset = settings.ResetEvery == CrowdfundResetEvery.Never,
+                CurrencyData = _Currencies.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
+                }
+            };
+        }
+
+        public static string GetCrowdfundOrderId(string appId) => $"crowdfund-app_{appId}";
+        public static string GetAppInternalTag(string appId) => $"APP#{appId}";
+        public static string[] GetAppInternalTags(IEnumerable<string> tags)
+        {
+            return tags == null ? Array.Empty<string>() : tags
+                                                  .Where(t => t.StartsWith("APP#", StringComparison.InvariantCulture))
+                                                  .Select(t => t.Substring("APP#".Length)).ToArray();
+        }
+        private async Task<InvoiceEntity[]> GetInvoicesForApp(AppData appData, DateTime? startDate = null)
+        {
+            var invoices = await _InvoiceRepository.GetInvoices(new InvoiceQuery()
+            {
+                StoreId = new[] { appData.StoreData.Id },
+                OrderId = appData.TagAllInvoices ? null : new[] { GetCrowdfundOrderId(appData.Id) },
+                Status = new string[]{
+                    InvoiceState.ToString(InvoiceStatus.New),
+                    InvoiceState.ToString(InvoiceStatus.Paid),
+                    InvoiceState.ToString(InvoiceStatus.Confirmed),
+                    InvoiceState.ToString(InvoiceStatus.Complete)},
+                StartDate = startDate
+            });
+
+            // Old invoices may have invoices which were not tagged
+            invoices = invoices.Where(inv => inv.Version < InvoiceEntity.InternalTagSupport_Version ||
+                                             inv.InternalTags.Contains(GetAppInternalTag(appData.Id))).ToArray();
+            return invoices;
+        }
+
+        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 = _HtmlSanitizer.Sanitize(c.GetDetailString("description")),
+                    Id = c.Key,
+                    Image = _HtmlSanitizer.Sanitize(c.GetDetailString("image")),
+                    Title = _HtmlSanitizer.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 = Currencies.FormatCurrency(cc.Value.Value, currency)
+                             }).Single(),
+                    Custom = c.GetDetailString("custom") == "true"
+                })
+                .ToArray();
+        }
+
+        public async Task<decimal> GetCurrentContributionAmount(Dictionary<string, decimal> stats, string primaryCurrency, RateRules rateRules)
+        {
+            var result = new List<decimal>();
+
+            var ratesTask = _RateFetcher.FetchRates(
+                stats.Keys
+                    .Select((x) => new CurrencyPair(primaryCurrency, PaymentMethodId.Parse(x).CryptoCode))
+                    .Distinct()
+                    .ToHashSet(),
+                rateRules).Select(async rateTask =>
+                {
+                    var (key, value) = rateTask;
+                    var tResult = await value;
+                    var rate = tResult.BidAsk?.Bid;
+                    if (rate == null)
+                        return;
+
+                    foreach (var stat in stats)
+                    {
+                        if (string.Equals(PaymentMethodId.Parse(stat.Key).CryptoCode, key.Right,
+                            StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            result.Add((1m / rate.Value) * stat.Value);
+                        }
+                    }
+                });
+
+            await Task.WhenAll(ratesTask);
+
+            return result.Sum();
+        }
+
+        public Dictionary<string, decimal> GetCurrentContributionAmountStats(InvoiceEntity[] invoices, bool softcap)
+        {
+            return invoices
+                .SelectMany(p =>
+                {
+                    // For hardcap, we count newly created invoices as part of the contributions
+                    if (!softcap && p.Status == InvoiceStatus.New)
+                        return new[] { (Key: p.ProductInformation.Currency, Value: p.ProductInformation.Price) };
+
+                    // If the user get a donation via other mean, he can register an invoice manually for such amount
+                    // then mark the invoice as complete
+                    var payments = p.GetPayments();
+                    if (payments.Count == 0 &&
+                        p.ExceptionStatus == InvoiceExceptionStatus.Marked &&
+                        p.Status == InvoiceStatus.Complete)
+                        return new[] { (Key: p.ProductInformation.Currency, Value: p.ProductInformation.Price) };
+
+                    // If an invoice has been marked invalid, remove the contribution
+                    if (p.ExceptionStatus == InvoiceExceptionStatus.Marked &&
+                        p.Status == InvoiceStatus.Invalid)
+                        return new[] { (Key: p.ProductInformation.Currency, Value: 0m) };
+
+                    // Else, we just sum the payments
+                    return payments
+                             .Select(pay => (Key: pay.GetPaymentMethodId().ToString(), Value: pay.GetCryptoPaymentData().GetValue()))
+                             .ToArray();
+                })
+                .GroupBy(p => p.Key)
+                .ToDictionary(p => p.Key, p => p.Select(v => v.Value).Sum());
+        }
+
+        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 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/Services/Apps/AppType.cs

@@ -7,6 +7,7 @@ namespace BTCPayServer.Services.Apps
 {
     public enum AppType
     {
-        PointOfSale
+        PointOfSale,
+        Crowdfund
     }
 }

BTCPayServer/Services/Apps/CrowdfundSettings.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Services.Apps
+{
+    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 int ResetEveryAmount { get; set; } = 1;
+        public CrowdfundResetEvery ResetEvery { get; set; } = CrowdfundResetEvery.Never;
+        [Obsolete("Use AppData.TagAllInvoices instead")]
+        public bool UseAllStoreInvoices { get; set; }
+        public bool DisplayPerksRanking { get; set; }
+        public bool SortPerksByPopularity { get; set; }
+    }
+    public enum CrowdfundResetEvery
+    {
+        Never,
+        Hour,
+        Day,
+        Month,
+        Year
+    }
+}

BTCPayServer/Services/HardwareWalletService.cs

@@ -89,20 +89,19 @@ namespace BTCPayServer.Services
             return new LedgerTestResult() { Success = true };
         }
 
-        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network, int account, CancellationToken cancellation)
+        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network, KeyPath keyPath, CancellationToken cancellation)
         {
             if (network == null)
                 throw new ArgumentNullException(nameof(network));
 
             var segwit = network.NBitcoinNetwork.Consensus.SupportSegwit;
-            var path = network.GetRootKeyPath().Derive(account, true);
-            var pubkey = await GetExtPubKey(Ledger, network, path, false, cancellation);
+            var pubkey = await GetExtPubKey(Ledger, network, keyPath, false, cancellation);
             var derivation = new DerivationStrategyFactory(network.NBitcoinNetwork).CreateDirectDerivationStrategy(pubkey, new DerivationStrategyOptions()
             {
                 P2SH = segwit,
                 Legacy = !segwit
             });
-            return new GetXPubResult() { ExtPubKey = derivation.ToString(), KeyPath = path };
+            return new GetXPubResult() { ExtPubKey = derivation.ToString(), KeyPath = keyPath };
         }
 
         private static async Task<BitcoinExtPubKey> GetExtPubKey(LedgerClient ledger, BTCPayNetwork network, KeyPath account, bool onlyChaincode, CancellationToken cancellation)
@@ -129,7 +128,13 @@ namespace BTCPayServer.Services
             }
         }
 
-        public async Task<KeyPath> GetKeyPath(BTCPayNetwork network, DirectDerivationStrategy directStrategy, CancellationToken cancellation)
+        public async Task<bool> CanSign(BTCPayNetwork network, DirectDerivationStrategy strategy, KeyPath keyPath, CancellationToken cancellation)
+        {
+            var hwKey = await GetExtPubKey(Ledger, network, keyPath, true, cancellation);
+            return hwKey.ExtPubKey.PubKey == strategy.Root.PubKey;
+        }
+
+        public async Task<KeyPath> FindKeyPath(BTCPayNetwork network, DirectDerivationStrategy directStrategy, CancellationToken cancellation)
         {
             List<KeyPath> derivations = new List<KeyPath>();
             if (network.NBitcoinNetwork.Consensus.SupportSegwit)
@@ -164,7 +169,17 @@ namespace BTCPayServer.Services
                                                      KeyPath changeKeyPath,
                                                      CancellationToken cancellationToken)
         {
-            return await Ledger.SignTransactionAsync(signatureRequests, unsigned, changeKeyPath, cancellationToken);
+            try
+            {
+                var signedTransaction = await Ledger.SignTransactionAsync(signatureRequests, unsigned, changeKeyPath, cancellationToken);
+                if (signedTransaction == null)
+                    throw new Exception("The ledger failed to sign the transaction");
+                return signedTransaction;
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("The ledger failed to sign the transaction", ex);
+            }
         }
 
         public void Dispose()

BTCPayServer/Services/IBackgroundJobClient.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Services
+{
+    public interface IBackgroundJobClient
+    {
+        void Schedule(Func<Task> act, TimeSpan zero);
+    }
+}

BTCPayServer/Services/Invoices/Export/InvoiceExport.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Payments.Bitcoin;
 using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
 using Newtonsoft.Json;
 
 namespace BTCPayServer.Services.Invoices.Export
@@ -12,10 +13,12 @@ namespace BTCPayServer.Services.Invoices.Export
     public class InvoiceExport
     {
         public BTCPayNetworkProvider Networks { get; }
+        public CurrencyNameTable Currencies { get; }
 
-        public InvoiceExport(BTCPayNetworkProvider networks)
+        public InvoiceExport(BTCPayNetworkProvider networks, CurrencyNameTable currencies)
         {
             Networks = networks;
+            Currencies = currencies;
         }
         public string Process(InvoiceEntity[] invoices, string fileFormat)
         {
@@ -52,17 +55,21 @@ namespace BTCPayServer.Services.Invoices.Export
         private IEnumerable<ExportInvoiceHolder> convertFromDb(InvoiceEntity invoice)
         {
             var exportList = new List<ExportInvoiceHolder>();
+            var currency = Currencies.GetNumberFormatInfo(invoice.ProductInformation.Currency, true);
+
+            var invoiceDue = invoice.ProductInformation.Price;
             // in this first version we are only exporting invoices that were paid
             foreach (var payment in invoice.GetPayments())
             {
                 // not accounted payments are payments which got double spent like RBfed
                 if (!payment.Accounted)
                     continue;
-
                 var cryptoCode = payment.GetPaymentMethodId().CryptoCode;
                 var pdata = payment.GetCryptoPaymentData();
 
                 var pmethod = invoice.GetPaymentMethod(payment.GetPaymentMethodId(), Networks);
+                var paidAfterNetworkFees = pdata.GetValue() - payment.NetworkFee;
+                invoiceDue -=  paidAfterNetworkFees * pmethod.Rate;
 
                 var target = new ExportInvoiceHolder
                 {
@@ -73,6 +80,13 @@ namespace BTCPayServer.Services.Invoices.Export
                     PaymentType = payment.GetPaymentMethodId().PaymentType == Payments.PaymentTypes.BTCLike ? "OnChain" : "OffChain",
                     Destination = payment.GetCryptoPaymentData().GetDestination(Networks.GetNetwork(cryptoCode)),
                     Paid = pdata.GetValue().ToString(CultureInfo.InvariantCulture),
+                    PaidCurrency = Math.Round(pdata.GetValue() * pmethod.Rate, currency.NumberDecimalDigits).ToString(CultureInfo.InvariantCulture),
+                    // Adding NetworkFee because Paid doesn't take into account network fees
+                    // so if fee is 10000 satoshis, customer can essentially send infinite number of tx
+                    // and merchant effectivelly would receive 0 BTC, invoice won't be paid
+                    // while looking just at export you could sum Paid and assume merchant "received payments"
+                    NetworkFee = payment.NetworkFee.ToString(CultureInfo.InvariantCulture),
+                    InvoiceDue = Math.Round(invoiceDue, currency.NumberDecimalDigits),
                     OrderId = invoice.OrderId,
                     StoreId = invoice.StoreId,
                     InvoiceId = invoice.Id,
@@ -88,6 +102,7 @@ namespace BTCPayServer.Services.Invoices.Export
                     InvoiceItemDesc = invoice.ProductInformation.ItemDesc,
                     InvoicePrice = invoice.ProductInformation.Price,
                     InvoiceCurrency = invoice.ProductInformation.Currency,
+                    BuyerEmail = invoice.BuyerInformation?.BuyerEmail
                 };
 
                 exportList.Add(target);
@@ -112,16 +127,19 @@ namespace BTCPayServer.Services.Invoices.Export
         public string PaymentId { get; set; }
         public string Destination { get; set; }
         public string PaymentType { get; set; }
-        public string Paid { get; set; }
         public string CryptoCode { get; set; }
+        public string Paid { get; set; }
+        public string NetworkFee { get; set; }
         public decimal ConversionRate { get; set; }
-
-        public decimal InvoicePrice { get; set; }
+        public string PaidCurrency { get; set; }
         public string InvoiceCurrency { get; set; }
+        public decimal InvoiceDue { get; set; }
+        public decimal InvoicePrice { get; set; }
         public string InvoiceItemCode { get; set; }
         public string InvoiceItemDesc { get; set; }
         public string InvoiceFullStatus { get; set; }
         public string InvoiceStatus { get; set; }
         public string InvoiceExceptionStatus { get; set; }
+        public string BuyerEmail { get; set; }
     }
 }

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -91,6 +91,12 @@ namespace BTCPayServer.Services.Invoices
             get; set;
         }
 
+        [JsonProperty(PropertyName = "taxIncluded", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public decimal TaxIncluded
+        {
+            get; set;
+        }
+
         [JsonProperty(PropertyName = "currency")]
         public string Currency
         {
@@ -107,6 +113,8 @@ namespace BTCPayServer.Services.Invoices
     }
     public class InvoiceEntity
     {
+        public const int InternalTagSupport_Version = 1;
+        public int Version { get; set; } = 1;
         public string Id
         {
             get; set;
@@ -158,6 +166,9 @@ namespace BTCPayServer.Services.Invoices
             set;
         }
 
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public HashSet<string> InternalTags { get; set; } = new HashSet<string>();
+        
         [Obsolete("Use GetDerivationStrategies instead")]
         public string DerivationStrategy
         {
@@ -344,6 +355,7 @@ namespace BTCPayServer.Services.Invoices
             InvoiceResponse dto = new InvoiceResponse
             {
                 Id = Id,
+                StoreId = StoreId,
                 OrderId = OrderId,
                 PosData = PosData,
                 CurrentTime = DateTimeOffset.UtcNow,
@@ -485,7 +497,7 @@ namespace BTCPayServer.Services.Invoices
 
         public PaymentMethodDictionary GetPaymentMethods(BTCPayNetworkProvider networkProvider)
         {
-            PaymentMethodDictionary rates = new PaymentMethodDictionary(networkProvider);
+            PaymentMethodDictionary paymentMethods = new PaymentMethodDictionary();
             var serializer = new Serializer(Dummy);
 #pragma warning disable CS0618
             if (PaymentMethod != null)
@@ -499,11 +511,11 @@ namespace BTCPayServer.Services.Invoices
                     r.ParentEntity = this;
                     r.Network = networkProvider?.GetNetwork(r.CryptoCode);
                     if (r.Network != null || networkProvider == null)
-                        rates.Add(r);
+                        paymentMethods.Add(r);
                 }
             }
 #pragma warning restore CS0618
-            return rates;
+            return paymentMethods;
         }
 
         Network Dummy = Network.Main;
@@ -517,8 +529,6 @@ namespace BTCPayServer.Services.Invoices
 
         public void SetPaymentMethods(PaymentMethodDictionary paymentMethods)
         {
-            if (paymentMethods.NetworkProvider != null)
-                throw new InvalidOperationException($"{nameof(paymentMethods)} should have NetworkProvider to null");
             var obj = new JObject();
             var serializer = new Serializer(Dummy);
 #pragma warning disable CS0618
@@ -681,7 +691,7 @@ namespace BTCPayServer.Services.Invoices
         /// </summary>
         public Money NetworkFee { get; set; }
         /// <summary>
-        /// Minimum required to be paid in order to accept invocie as paid
+        /// Minimum required to be paid in order to accept invoice as paid
         /// </summary>
         public Money MinimumTotalDue { get; set; }
     }
@@ -731,7 +741,7 @@ namespace BTCPayServer.Services.Invoices
                 {
                     FeeRate = FeeRate,
                     DepositAddress = string.IsNullOrEmpty(DepositAddress) ? null : DepositAddress,
-                    TxFee = TxFee
+                    NextNetworkFee = NextNetworkFee
                 };
             }
             else
@@ -739,7 +749,7 @@ namespace BTCPayServer.Services.Invoices
                 var details = PaymentMethodExtensions.DeserializePaymentMethodDetails(GetId(), PaymentMethodDetails);
                 if (details is Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod btcLike)
                 {
-                    btcLike.TxFee = TxFee;
+                    btcLike.NextNetworkFee = NextNetworkFee;
                     btcLike.DepositAddress = string.IsNullOrEmpty(DepositAddress) ? null : DepositAddress;
                     btcLike.FeeRate = FeeRate;
                 }
@@ -761,7 +771,7 @@ namespace BTCPayServer.Services.Invoices
 
             if (paymentMethod is Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod bitcoinPaymentMethod)
             {
-                TxFee = bitcoinPaymentMethod.TxFee;
+                NextNetworkFee = bitcoinPaymentMethod.NextNetworkFee;
                 FeeRate = bitcoinPaymentMethod.FeeRate;
                 DepositAddress = bitcoinPaymentMethod.DepositAddress;
             }
@@ -776,8 +786,8 @@ namespace BTCPayServer.Services.Invoices
         [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).FeeRate")]
         public FeeRate FeeRate { get; set; }
         [JsonProperty(PropertyName = "txFee")]
-        [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).TxFee")]
-        public Money TxFee { get; set; }
+        [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).NextNetworkFee")]
+        public Money NextNetworkFee { get; set; }
         [JsonProperty(PropertyName = "depositAddress")]
         [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).DepositAddress")]
         public string DepositAddress { get; set; }
@@ -801,7 +811,7 @@ namespace BTCPayServer.Services.Invoices
                 .OrderBy(p => p.ReceivedTime)
                 .Select(_ =>
                 {
-                    var txFee = _.GetValue(paymentMethods, GetId(), paymentMethods[_.GetPaymentMethodId()].GetTxFee());
+                    var txFee = _.GetValue(paymentMethods, GetId(), _.NetworkFee);
                     paid += _.GetValue(paymentMethods, GetId());
                     if (!paidEnough)
                     {
@@ -842,17 +852,18 @@ namespace BTCPayServer.Services.Invoices
             var method = GetPaymentMethodDetails();
             if (method == null)
                 return 0.0m;
-            return method.GetTxFee();
+            return method.GetNextNetworkFee();
         }
     }
 
     public class PaymentEntity
     {
+        public int Version { get; set; }
         public DateTimeOffset ReceivedTime
         {
             get; set;
         }
-
+        public decimal NetworkFee { get; set; }
         [Obsolete("Use ((BitcoinLikePaymentData)GetCryptoPaymentData()).Outpoint")]
         public OutPoint Outpoint
         {
@@ -889,7 +900,7 @@ namespace BTCPayServer.Services.Invoices
 #pragma warning disable CS0618
             if (string.IsNullOrEmpty(CryptoPaymentDataType))
             {
-                // In case this is a payment done before this update, consider it unconfirmed with RBF for safety
+                // For invoices created when CryptoPaymentDataType was not existing, we just consider that it is a RBFed payment for safety
                 var paymentData = new Payments.Bitcoin.BitcoinLikePaymentData();
                 paymentData.Outpoint = Outpoint;
                 paymentData.Output = Output;

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -41,7 +41,7 @@ namespace BTCPayServer.Services.Invoices
         public InvoiceRepository(ApplicationDbContextFactory contextFactory, string dbreezePath)
         {
             int retryCount = 0;
-            retry:
+retry:
             try
             {
                 _Engine = new DBreezeEngine(dbreezePath);
@@ -93,6 +93,16 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
+        public async Task<AppData[]> GetAppsTaggingStore(string storeId)
+        {
+            if (storeId == null)
+                throw new ArgumentNullException(nameof(storeId));
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                return await ctx.Apps.Where(a => a.StoreDataId == storeId && a.TagAllInvoices).ToArrayAsync();
+            }
+        }
+
         public async Task UpdateInvoice(string invoiceId, UpdateCustomerModel data)
         {
             using (var ctx = _ContextFactory.CreateContext())
@@ -178,7 +188,6 @@ namespace BTCPayServer.Services.Invoices
             textSearch.Add(invoice.StoreId);
 
             AddToTextSearch(invoice.Id, textSearch.ToArray());
-
             return invoice;
         }
 
@@ -193,7 +202,7 @@ namespace BTCPayServer.Services.Invoices
             return paymentMethod.GetPaymentMethodDetails().GetPaymentDestination();
         }
 
-        public async Task<bool> NewAddress(string invoiceId, IPaymentMethodDetails paymentMethod, BTCPayNetwork network)
+        public async Task<bool> NewAddress(string invoiceId, Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod paymentMethod, BTCPayNetwork network)
         {
             using (var context = _ContextFactory.CreateContext())
             {
@@ -206,14 +215,13 @@ namespace BTCPayServer.Services.Invoices
                 if (currencyData == null)
                     return false;
 
-                var existingPaymentMethod = currencyData.GetPaymentMethodDetails();
+                var existingPaymentMethod = (Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod)currencyData.GetPaymentMethodDetails();
                 if (existingPaymentMethod.GetPaymentDestination() != null)
                 {
                     MarkUnassigned(invoiceId, invoiceEntity, context, currencyData.GetId());
                 }
 
                 existingPaymentMethod.SetPaymentDestination(paymentMethod.GetPaymentDestination());
-
                 currencyData.SetPaymentMethodDetails(existingPaymentMethod);
 #pragma warning disable CS0618
                 if (network.IsBTC)
@@ -379,13 +387,27 @@ namespace BTCPayServer.Services.Invoices
         private InvoiceEntity ToEntity(Data.InvoiceData invoice)
         {
             var entity = ToObject<InvoiceEntity>(invoice.Blob, null);
+            PaymentMethodDictionary paymentMethods = null;
 #pragma warning disable CS0618
             entity.Payments = invoice.Payments.Select(p =>
             {
                 var paymentEntity = ToObject<PaymentEntity>(p.Blob, null);
                 paymentEntity.Accounted = p.Accounted;
+
+                // PaymentEntity on version 0 does not have their own fee, because it was assumed that the payment method have fixed fee.
+                // We want to hide this legacy detail in InvoiceRepository, so we fetch the fee from the PaymentMethod and assign it to the PaymentEntity.
+                if (paymentEntity.Version == 0)
+                {
+                    if (paymentMethods == null)
+                        paymentMethods = entity.GetPaymentMethods(null);
+                    var paymentMethodDetails = paymentMethods.TryGet(paymentEntity.GetPaymentMethodId())?.GetPaymentMethodDetails();
+                    if (paymentMethodDetails != null) // == null should never happen, but we never know.
+                        paymentEntity.NetworkFee = paymentMethodDetails.GetNextNetworkFee();
+                }
+
                 return paymentEntity;
-            }).ToList();
+            })
+            .OrderBy(a => a.ReceivedTime).ToList();
 #pragma warning restore CS0618
             var state = invoice.GetInvoiceState();
             entity.ExceptionStatus = state.ExceptionStatus;
@@ -407,86 +429,108 @@ namespace BTCPayServer.Services.Invoices
             return entity;
         }
 
+        private IQueryable<Data.InvoiceData> GetInvoiceQuery(ApplicationDbContext context, InvoiceQuery queryObject)
+        {
+            IQueryable<Data.InvoiceData> query = context.Invoices;
+
+            if (!string.IsNullOrEmpty(queryObject.InvoiceId))
+            {
+                query = query.Where(i => i.Id == queryObject.InvoiceId);
+            }
+
+            if (queryObject.StoreId != null && queryObject.StoreId.Length > 0)
+            {
+                var stores = queryObject.StoreId.ToHashSet();
+                query = query.Where(i => stores.Contains(i.StoreDataId));
+            }
+
+            if (queryObject.UserId != null)
+            {
+                query = query.Where(i => i.StoreData.UserStores.Any(u => u.ApplicationUserId == queryObject.UserId));
+            }
+
+            if (!string.IsNullOrEmpty(queryObject.TextSearch))
+            {
+                var ids = new HashSet<string>(SearchInvoice(queryObject.TextSearch));
+                if (ids.Count == 0)
+                {
+                    // Hacky way to return an empty query object. The nice way is much too elaborate:
+                    // https://stackoverflow.com/questions/33305495/how-to-return-empty-iqueryable-in-an-async-repository-method
+                    return query.Where(x => false); 
+                }
+                query = query.Where(i => ids.Contains(i.Id));
+            }
+
+            if (queryObject.StartDate != null)
+                query = query.Where(i => queryObject.StartDate.Value <= i.Created);
+
+            if (queryObject.EndDate != null)
+                query = query.Where(i => i.Created <= queryObject.EndDate.Value);
+
+            if (queryObject.OrderId != null && queryObject.OrderId.Length > 0)
+            {
+                var statusSet = queryObject.OrderId.ToHashSet();
+                query = query.Where(i => statusSet.Contains(i.OrderId));
+            }
+            if (queryObject.ItemCode != null && queryObject.ItemCode.Length > 0)
+            {
+                var statusSet = queryObject.ItemCode.ToHashSet();
+                query = query.Where(i => statusSet.Contains(i.ItemCode));
+            }
+
+            if (queryObject.Status != null && queryObject.Status.Length > 0)
+            {
+                var statusSet = queryObject.Status.ToHashSet();
+                query = query.Where(i => statusSet.Contains(i.Status));
+            }
+
+            if (queryObject.Unusual != null)
+            {
+                var unused = queryObject.Unusual.Value;
+                query = query.Where(i => unused == (i.Status == "invalid" || i.ExceptionStatus != null));
+            }
+
+            if (queryObject.ExceptionStatus != null && queryObject.ExceptionStatus.Length > 0)
+            {
+                var exceptionStatusSet = queryObject.ExceptionStatus.Select(s => NormalizeExceptionStatus(s)).ToHashSet();
+                query = query.Where(i => exceptionStatusSet.Contains(i.ExceptionStatus));
+            }
+
+            query = query.OrderByDescending(q => q.Created);
+
+            if (queryObject.Skip != null)
+                query = query.Skip(queryObject.Skip.Value);
+
+            if (queryObject.Count != null)
+                query = query.Take(queryObject.Count.Value);
+
+            return query;
+        }
+
+        public async Task<int> GetInvoicesTotal(InvoiceQuery queryObject)
+        {
+            using (var context = _ContextFactory.CreateContext())
+            {
+                var query = GetInvoiceQuery(context, queryObject);
+                return await query.CountAsync();
+            }
+        }
 
         public async Task<InvoiceEntity[]> GetInvoices(InvoiceQuery queryObject)
         {
             using (var context = _ContextFactory.CreateContext())
             {
-                IQueryable<Data.InvoiceData> query = context
-                    .Invoices
-                    .Include(o => o.Payments)
+                var query = GetInvoiceQuery(context, queryObject);
+                query = query.Include(o => o.Payments)
                     .Include(o => o.RefundAddresses);
                 if (queryObject.IncludeAddresses)
                     query = query.Include(o => o.HistoricalAddressInvoices).Include(o => o.AddressInvoices);
                 if (queryObject.IncludeEvents)
                     query = query.Include(o => o.Events);
-                if (!string.IsNullOrEmpty(queryObject.InvoiceId))
-                {
-                    query = query.Where(i => i.Id == queryObject.InvoiceId);
-                }
-
-                if (queryObject.StoreId != null && queryObject.StoreId.Length > 0)
-                {
-                    var stores = queryObject.StoreId.ToHashSet();
-                    query = query.Where(i => stores.Contains(i.StoreDataId));
-                }
-
-                if (queryObject.UserId != null)
-                {
-                    query = query.Where(i => i.StoreData.UserStores.Any(u => u.ApplicationUserId == queryObject.UserId));
-                }
-
-                if (!string.IsNullOrEmpty(queryObject.TextSearch))
-                {
-                    var ids = new HashSet<string>(SearchInvoice(queryObject.TextSearch));
-                    if (ids.Count == 0)
-                        return Array.Empty<InvoiceEntity>();
-                    query = query.Where(i => ids.Contains(i.Id));
-                }
-
-                if (queryObject.StartDate != null)
-                    query = query.Where(i => queryObject.StartDate.Value <= i.Created);
-
-                if (queryObject.EndDate != null)
-                    query = query.Where(i => i.Created <= queryObject.EndDate.Value);
-
-                if (queryObject.ItemCode != null)
-                    query = query.Where(i => i.ItemCode == queryObject.ItemCode);
-
-                if (queryObject.OrderId != null)
-                    query = query.Where(i => i.OrderId == queryObject.OrderId);
-
-                if (queryObject.Status != null && queryObject.Status.Length > 0)
-                {
-                    var statusSet = queryObject.Status.ToHashSet();
-                    query = query.Where(i => statusSet.Contains(i.Status));
-                }
-
-                if (queryObject.Unusual != null)
-                {
-                    var unused = queryObject.Unusual.Value;
-                    query = query.Where(i => unused == (i.Status == "invalid" || i.ExceptionStatus != null));
-                }
-
-                if (queryObject.ExceptionStatus != null && queryObject.ExceptionStatus.Length > 0)
-                {
-                    var exceptionStatusSet = queryObject.ExceptionStatus.Select(s => NormalizeExceptionStatus(s)).ToHashSet();
-                    query = query.Where(i => exceptionStatusSet.Contains(i.ExceptionStatus));
-                }
-
-                query = query.OrderByDescending(q => q.Created);
-
-                if (queryObject.Skip != null)
-                    query = query.Skip(queryObject.Skip.Value);
-
-                if (queryObject.Count != null)
-                    query = query.Take(queryObject.Count.Value);
 
                 var data = await query.ToArrayAsync().ConfigureAwait(false);
-
                 return data.Select(ToEntity).ToArray();
             }
-
         }
 
         private string NormalizeExceptionStatus(string status)
@@ -546,21 +590,37 @@ namespace BTCPayServer.Services.Invoices
         /// <param name="cryptoCode"></param>
         /// <param name="accounted"></param>
         /// <returns>The PaymentEntity or null if already added</returns>
-        public async Task<PaymentEntity> AddPayment(string invoiceId, DateTimeOffset date, CryptoPaymentData paymentData, string cryptoCode, bool accounted = false)
+        public async Task<PaymentEntity> AddPayment(string invoiceId, DateTimeOffset date, CryptoPaymentData paymentData, BTCPayNetwork network, bool accounted = false)
         {
             using (var context = _ContextFactory.CreateContext())
             {
+                var invoice = context.Invoices.Find(invoiceId);
+                if (invoice == null)
+                    return null;
+                InvoiceEntity invoiceEntity = ToObject<InvoiceEntity>(invoice.Blob, network.NBitcoinNetwork);
+                PaymentMethod paymentMethod = invoiceEntity.GetPaymentMethod(new PaymentMethodId(network.CryptoCode, paymentData.GetPaymentType()), null);
+                IPaymentMethodDetails paymentMethodDetails = paymentMethod.GetPaymentMethodDetails();
                 PaymentEntity entity = new PaymentEntity
                 {
+                    Version = 1,
 #pragma warning disable CS0618
-                    CryptoCode = cryptoCode,
+                    CryptoCode = network.CryptoCode,
 #pragma warning restore CS0618
                     ReceivedTime = date.UtcDateTime,
-                    Accounted = accounted
+                    Accounted = accounted,
+                    NetworkFee = paymentMethodDetails.GetNextNetworkFee()
                 };
                 entity.SetCryptoPaymentData(paymentData);
 
-
+                if (paymentMethodDetails is Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod bitcoinPaymentMethod &&
+                    bitcoinPaymentMethod.NetworkFeeMode == NetworkFeeMode.MultiplePaymentsOnly &&
+                    bitcoinPaymentMethod.NextNetworkFee == Money.Zero)
+                {
+                    bitcoinPaymentMethod.NextNetworkFee = bitcoinPaymentMethod.FeeRate.GetFee(100); // assume price for 100 bytes
+                    paymentMethod.SetPaymentMethodDetails(bitcoinPaymentMethod);
+                    invoiceEntity.SetPaymentMethod(paymentMethod);
+                    invoice.Blob = ToBytes(invoiceEntity, network.NBitcoinNetwork);
+                }
                 PaymentData data = new PaymentData
                 {
                     Id = paymentData.GetPaymentId(),
@@ -665,12 +725,12 @@ namespace BTCPayServer.Services.Invoices
             get; set;
         }
 
-        public string OrderId
+        public string[] OrderId
         {
             get; set;
         }
 
-        public string ItemCode
+        public string[] ItemCode
         {
             get; set;
         }