bump

* allow cancel on un paid new invoices in payment requests

* start work on cancel pr payment

* finish up cancel action

* final touch and add tests

.circleci/config.yml

@@ -16,7 +16,11 @@ jobs:
             cd BTCPayServer.Tests
             docker-compose down --v
             docker-compose build
-            docker-compose run tests
+            TESTS_RUN_EXTERNAL_INTEGRATION="true"
+            if [ -n "$CIRCLE_PULL_REQUEST" ] || [ -n "$CIRCLE_PR_NUMBER" ]; then
+                TESTS_RUN_EXTERNAL_INTEGRATION="false"
+            fi
+            docker-compose run -e TESTS_RUN_EXTERNAL_INTEGRATION=$TESTS_RUN_EXTERNAL_INTEGRATION tests
 
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
   publish_docker_linuxamd64:

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -33,4 +33,5 @@
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer\BTCPayServer.csproj" />
   </ItemGroup>
+
 </Project>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -110,7 +110,6 @@ namespace BTCPayServer.Tests
 
             config.AppendLine($"ltc.explorer.url={LTCNBXplorerUri.AbsoluteUri}");
             config.AppendLine($"ltc.explorer.cookiefile=0");
-
             config.AppendLine($"btc.lightning={IntegratedLightning.AbsoluteUri}");
 
             if (TestDatabase == TestDatabases.MySQL && !String.IsNullOrEmpty(MySQL))
@@ -127,6 +126,7 @@ namespace BTCPayServer.Tests
             var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath, "--disable-registration", "false" });
             _Host = new WebHostBuilder()
                     .UseConfiguration(conf)
+                    .UseContentRoot(FindBTCPayServerDirectory())
                     .ConfigureServices(s =>
                     {
                         s.AddLogging(l =>
@@ -211,6 +211,12 @@ namespace BTCPayServer.Tests
             }
         }
 
+        private string FindBTCPayServerDirectory()
+        {
+            var solutionDirectory = LanguageService.TryGetSolutionDirectoryInfo(Directory.GetCurrentDirectory());
+            return Path.Combine(solutionDirectory.FullName, "BTCPayServer");
+        }
+
         public HttpClient HttpClient { get; set; }
 
         public string HostName

BTCPayServer.Tests/PaymentRequestTests.cs

@@ -153,5 +153,64 @@ namespace BTCPayServer.Tests
                 
             }
         }
+        
+        [Fact(Timeout = 60 * 2 * 1000)]
+        [Trait("Integration", "Integration")]
+        public async Task CanCancelPaymentWhenPossible()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                var paymentRequestController = user.GetController<PaymentRequestController>();
+                
+                
+                Assert.IsType<NotFoundResult>(await 
+                    paymentRequestController.CancelUnpaidPendingInvoice(Guid.NewGuid().ToString(), false));
+
+
+                var request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice",
+                    Currency = "BTC",
+                    Amount = 1,
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                var response = Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
+                    .RouteValues.First();
+
+                var paymentRequestId = response.Value.ToString();
+                
+                var invoiceId = Assert
+                    .IsType<OkObjectResult>(await paymentRequestController.PayPaymentRequest(paymentRequestId, false)).Value
+                    .ToString();
+
+                var actionResult = Assert
+                    .IsType<RedirectToActionResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString()));
+
+                Assert.Equal("Checkout", actionResult.ActionName);
+                Assert.Equal("Invoice", actionResult.ControllerName);
+                Assert.Contains(actionResult.RouteValues, pair => pair.Key == "Id" && pair.Value.ToString() == invoiceId);
+
+                var invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
+Assert.Equal(InvoiceState.ToString(InvoiceStatus.New), invoice.Status);
+                Assert.IsType<OkObjectResult>(await 
+                    paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId, false));
+                
+                invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
+                Assert.Equal(InvoiceState.ToString(InvoiceStatus.Invalid), invoice.Status);
+                
+                
+                Assert.IsType<BadRequestObjectResult>(await 
+                    paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId, false));
+                          
+                
+            }
+        }
     }
 }

BTCPayServer.Tests/README.md

@@ -41,10 +41,15 @@ You can call bitcoin-cli inside the container with `docker exec`, for example, i
 ```
 
 If you are using Powershell:
-```
+```powershell
 .\docker-bitcoin-cli.ps1 sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
 ```
 
+You can also generate blocks:
+```powershell
+.\docker-bitcoin-generate.ps1 3
+```
+
 ### Using the test litecoin-cli
 
 Same as bitcoin-cli, but with `.\docker-litecoin-cli.ps1` and `.\docker-litecoin-cli.sh` instead. 

BTCPayServer.Tests/ServerTester.cs

@@ -45,6 +45,7 @@ namespace BTCPayServer.Tests
 
             NetworkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
             ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_BTCRPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("BTC").NBitcoinNetwork);
+            ExplorerNode.ScanRPCCapabilities();
             LTCExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_LTCRPCCONNECTION", "server=http://127.0.0.1:43783;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("LTC").NBitcoinNetwork);
 
             ExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("BTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_BTCNBXPLORERURL", "http://127.0.0.1:32838/")));

BTCPayServer.Tests/StorageTests.cs

@@ -0,0 +1,250 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Models;
+using BTCPayServer.Models.ServerViewModels;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage.Configuration;
+using BTCPayServer.Storage.ViewModels;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Internal;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Resources;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class StorageTests
+    {
+        public StorageTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanConfigureStorage()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
+
+//                //For some reason, the tests cache something on circleci and this is set by default
+//                //Initially, there is no configuration, make sure we display the choices available to configure
+//                Assert.IsType<StorageSettings>(Assert.IsType<ViewResult>(await controller.Storage()).Model);
+//
+//                //the file list should tell us it's not configured:
+//                var viewFilesViewModelInitial =
+//                    Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files()).Model);
+//                Assert.False(viewFilesViewModelInitial.StorageConfigured);
+
+
+                //Once we select a provider, redirect to its view
+                var localResult = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.FileSystem
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), localResult.ActionName);
+                Assert.Equal(StorageProvider.FileSystem.ToString(), localResult.RouteValues["provider"]);
+
+
+                var AmazonS3result = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.AmazonS3
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), AmazonS3result.ActionName);
+                Assert.Equal(StorageProvider.AmazonS3.ToString(), AmazonS3result.RouteValues["provider"]);
+
+                var GoogleResult = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.GoogleCloudStorage
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), GoogleResult.ActionName);
+                Assert.Equal(StorageProvider.GoogleCloudStorage.ToString(), GoogleResult.RouteValues["provider"]);
+
+
+                var AzureResult = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.AzureBlobStorage
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), AzureResult.ActionName);
+                Assert.Equal(StorageProvider.AzureBlobStorage.ToString(), AzureResult.RouteValues["provider"]);
+
+                //Cool, we get redirected to the config pages
+                //Let's configure this stuff
+
+                //Let's try and cheat and go to an invalid storage provider config
+                Assert.Equal(nameof(Storage), (Assert
+                    .IsType<RedirectToActionResult>(await controller.StorageProvider("I am not a real provider"))
+                    .ActionName));
+
+                //ok no more messing around, let's configure this shit. 
+                var fileSystemStorageConfiguration = Assert.IsType<FileSystemStorageConfiguration>(Assert
+                    .IsType<ViewResult>(await controller.StorageProvider(StorageProvider.FileSystem.ToString()))
+                    .Model);
+
+                //local file system does not need config, easy days!
+                Assert.IsType<ViewResult>(
+                    await controller.EditFileSystemStorageProvider(fileSystemStorageConfiguration));
+
+                //ok cool, let's see if this got set right
+                var shouldBeRedirectingToLocalStorageConfigPage =
+                    Assert.IsType<RedirectToActionResult>(await controller.Storage());
+                Assert.Equal(nameof(StorageProvider), shouldBeRedirectingToLocalStorageConfigPage.ActionName);
+                Assert.Equal(StorageProvider.FileSystem,
+                    shouldBeRedirectingToLocalStorageConfigPage.RouteValues["provider"]);
+
+
+                //if we tell the settings page to force, it should allow us to select a new provider
+                Assert.IsType<ChooseStorageViewModel>(Assert.IsType<ViewResult>(await controller.Storage(true)).Model);
+
+                //awesome, now let's see if the files result says we're all set up
+                var viewFilesViewModel =
+                    Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files()).Model);
+                Assert.True(viewFilesViewModel.StorageConfigured);
+                Assert.Empty(viewFilesViewModel.Files);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanUseLocalProviderFiles()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
+
+                var fileSystemStorageConfiguration = Assert.IsType<FileSystemStorageConfiguration>(Assert
+                    .IsType<ViewResult>(await controller.StorageProvider(StorageProvider.FileSystem.ToString()))
+                    .Model);
+                Assert.IsType<ViewResult>(
+                    await controller.EditFileSystemStorageProvider(fileSystemStorageConfiguration));
+                
+                var shouldBeRedirectingToLocalStorageConfigPage =
+                    Assert.IsType<RedirectToActionResult>(await controller.Storage());
+                Assert.Equal(nameof(StorageProvider), shouldBeRedirectingToLocalStorageConfigPage.ActionName);
+                Assert.Equal(StorageProvider.FileSystem,
+                    shouldBeRedirectingToLocalStorageConfigPage.RouteValues["provider"]);
+
+
+                await CanUploadRemoveFiles(controller);
+            }
+        }
+
+        [Fact]
+        [Trait("ExternalIntegration", "ExternalIntegration")]
+        public async Task CanUseAzureBlobStorage()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
+                var azureBlobStorageConfiguration = Assert.IsType<AzureBlobStorageConfiguration>(Assert
+                    .IsType<ViewResult>(await controller.StorageProvider(StorageProvider.AzureBlobStorage.ToString()))
+                    .Model);
+
+                azureBlobStorageConfiguration.ConnectionString = GetFromSecrets("AzureBlobStorageConnectionString");
+                azureBlobStorageConfiguration.ContainerName = "testscontainer";
+                Assert.IsType<ViewResult>(
+                    await controller.EditAzureBlobStorageStorageProvider(azureBlobStorageConfiguration));
+
+
+                var shouldBeRedirectingToAzureStorageConfigPage =
+                    Assert.IsType<RedirectToActionResult>(await controller.Storage());
+                Assert.Equal(nameof(StorageProvider), shouldBeRedirectingToAzureStorageConfigPage.ActionName);
+                Assert.Equal(StorageProvider.AzureBlobStorage,
+                    shouldBeRedirectingToAzureStorageConfigPage.RouteValues["provider"]);
+
+                //seems like azure config worked, let's see if the conn string was actually saved
+
+                Assert.Equal(azureBlobStorageConfiguration.ConnectionString, Assert
+                    .IsType<AzureBlobStorageConfiguration>(Assert
+                        .IsType<ViewResult>(
+                            await controller.StorageProvider(StorageProvider.AzureBlobStorage.ToString()))
+                        .Model).ConnectionString);
+                
+                
+
+                await CanUploadRemoveFiles(controller);
+            }
+        }
+        
+        
+        private async Task CanUploadRemoveFiles(ServerController controller)
+        {
+            var filename = "uploadtestfile.txt";
+            var fileContent = "content";
+            File.WriteAllText(filename, fileContent);
+
+            var fileInfo = new FileInfo(filename);
+            var formFile = new FormFile(
+                new FileStream(filename, FileMode.OpenOrCreate),
+                0,
+                fileInfo.Length, fileInfo.Name, fileInfo.Name)
+            {
+                Headers = new HeaderDictionary()
+            };
+            formFile.ContentType = "text/plain";
+            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
+            var uploadFormFileResult = Assert.IsType<RedirectToActionResult>(await controller.CreateFile(formFile));
+            Assert.True(uploadFormFileResult.RouteValues.ContainsKey("fileId"));
+            var fileId = uploadFormFileResult.RouteValues["fileId"].ToString();
+            Assert.Equal("Files", uploadFormFileResult.ActionName);
+
+            var viewFilesViewModel =
+                Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files(fileId)).Model);
+
+            Assert.NotEmpty(viewFilesViewModel.Files);
+            Assert.Equal(fileId, viewFilesViewModel.SelectedFileId);
+            Assert.NotEmpty(viewFilesViewModel.DirectFileUrl);
+
+
+            var net = new System.Net.WebClient();
+            var data = await net.DownloadStringTaskAsync(new Uri(viewFilesViewModel.DirectFileUrl));
+            Assert.Equal(fileContent, data);
+
+            Assert.Equal(StatusMessageModel.StatusSeverity.Success, new StatusMessageModel(Assert
+                .IsType<RedirectToActionResult>(await controller.DeleteFile(fileId))
+                .RouteValues["statusMessage"].ToString()).Severity);
+
+            viewFilesViewModel =
+                Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files(fileId)).Model);
+
+            Assert.Null(viewFilesViewModel.DirectFileUrl);
+            Assert.Null(viewFilesViewModel.SelectedFileId);
+        }
+
+      
+
+        private static string GetFromSecrets(string key)
+        {
+            var connStr = Environment.GetEnvironmentVariable($"TESTS_{key}");
+            if (!string.IsNullOrEmpty(connStr) && connStr != "none")
+                return connStr;
+            var builder = new ConfigurationBuilder();
+            builder.AddUserSecrets("AB0AC1DD-9D26-485B-9416-56A33F268117");
+            var config = builder.Build();
+            var token = config[key];
+            Assert.False(token == null, $"{key} is not set.\n Run \"dotnet user-secrets set {key} <value>\"");
+            return token;
+        }
+    }
+}

BTCPayServer.Tests/TestAccount.cs

@@ -113,15 +113,18 @@ namespace BTCPayServer.Tests
         private async Task RegisterAsync()
         {
             var account = parent.PayTester.GetController<AccountController>();
-            await account.Register(new RegisterViewModel()
+            RegisterDetails = new RegisterViewModel()
             {
                 Email = Guid.NewGuid() + "@toto.com",
                 ConfirmPassword = "Kitten0@",
                 Password = "Kitten0@",
-            });
+            };
+            await account.Register(RegisterDetails);
             UserId = account.RegisteredUserId;
         }
 
+        public RegisterViewModel RegisterDetails{ get; set; }
+
         public Bitpay BitPay
         {
             get; set;

BTCPayServer.Tests/UnitTest1.cs

@@ -56,6 +56,8 @@ using BTCPayServer.Configuration;
 using System.Security;
 using System.Runtime.CompilerServices;
 using System.Net;
+using BTCPayServer.Models.AccountViewModels;
+using BTCPayServer.Services.U2F.Models;
 
 namespace BTCPayServer.Tests
 {
@@ -654,7 +656,6 @@ namespace BTCPayServer.Tests
                 var rescan = Assert.IsType<RescanWalletModel>(Assert.IsType<ViewResult>(walletController.WalletRescan(walletId).Result).Model);
                 Assert.False(rescan.Ok);
                 Assert.True(rescan.IsFullySync);
-                Assert.True(rescan.IsSegwit);
                 Assert.False(rescan.IsSupportedByCurrency);
                 Assert.False(rescan.IsServerAdmin);
 
@@ -743,6 +744,12 @@ namespace BTCPayServer.Tests
                 AssertSearchInvoice(acc, false, invoice.Id, $"exceptionstatus:paidOver");
                 AssertSearchInvoice(acc, true, invoice.Id, $"unusual:true");
                 AssertSearchInvoice(acc, false, invoice.Id, $"unusual:false");
+
+                var time = invoice.InvoiceTime;
+                AssertSearchInvoice(acc, true, invoice.Id, $"startdate:{time.ToString("yyyy-MM-dd HH:mm:ss")}");
+                AssertSearchInvoice(acc, true, invoice.Id, $"enddate:{time.ToStringLowerInvariant()}");
+                AssertSearchInvoice(acc, false, invoice.Id, $"startdate:{time.AddSeconds(1).ToString("yyyy-MM-dd HH:mm:ss")}");
+                AssertSearchInvoice(acc, false, invoice.Id, $"enddate:{time.AddSeconds(-1).ToString("yyyy-MM-dd HH:mm:ss")}");
             }
         }
 
@@ -880,22 +887,28 @@ namespace BTCPayServer.Tests
         [Trait("Fast", "Fast")]
         public void CanParseFilter()
         {
-            var filter = "storeid:abc status:abed blabhbalh ";
+            var filter = "storeid:abc, status:abed, blabhbalh ";
             var search = new SearchString(filter);
-            Assert.Equal("storeid:abc status:abed blabhbalh", search.ToString());
+            Assert.Equal("storeid:abc, status:abed, blabhbalh", search.ToString());
             Assert.Equal("blabhbalh", search.TextSearch);
             Assert.Single(search.Filters["storeid"]);
             Assert.Single(search.Filters["status"]);
             Assert.Equal("abc", search.Filters["storeid"].First());
             Assert.Equal("abed", search.Filters["status"].First());
 
-            filter = "status:abed status:abed2";
+            filter = "status:abed, status:abed2";
             search = new SearchString(filter);
-            Assert.Equal("status:abed status:abed2", search.ToString());
+            Assert.Equal("", search.TextSearch);
+            Assert.Equal("status:abed, status:abed2", search.ToString());
             Assert.Throws<KeyNotFoundException>(() => search.Filters["test"]);
             Assert.Equal(2, search.Filters["status"].Count);
             Assert.Equal("abed", search.Filters["status"].First());
             Assert.Equal("abed2", search.Filters["status"].Skip(1).First());
+
+            filter = "StartDate:2019-04-25 01:00 AM, hekki";
+            search = new SearchString(filter);
+            Assert.Equal("2019-04-25 01:00 AM", search.Filters["startdate"].First());
+            Assert.Equal("hekki", search.TextSearch);
         }
 
         [Fact]
@@ -1655,12 +1668,21 @@ donation:
                 Assert.Equal(10.00m, orangeInvoice.Price);
                 Assert.Equal("CAD", orangeInvoice.Currency);
                 Assert.Equal("orange", orangeInvoice.ItemDesc);
+                
+                
+                Assert.IsType<RedirectToActionResult>(publicApps.ViewPointOfSale(appId, 0, null, null, null, null, "apple").Result);
+
+                invoices = user.BitPay.GetInvoices();
+                var appleInvoice = invoices.SingleOrDefault(invoice => invoice.ItemCode.Equals("apple"));
+                Assert.NotNull(appleInvoice);
+                Assert.Equal("good apple", appleInvoice.ItemDesc);
+                
 
                 // testing custom amount
-                var action = Assert.IsType<RedirectToActionResult>(publicApps.ViewPointOfSale(appId, 5, null, null, null, null, "donation").Result);
+                var action = Assert.IsType<RedirectToActionResult>(publicApps.ViewPointOfSale(appId, 6.6m, null, null, null, null, "donation").Result);
                 Assert.Equal(nameof(InvoiceController.Checkout), action.ActionName);
                 invoices = user.BitPay.GetInvoices();
-                var donationInvoice = invoices.Single(i => i.Price == 5m);
+                var donationInvoice = invoices.Single(i => i.Price == 6.6m);
                 Assert.NotNull(donationInvoice);
                 Assert.Equal("CAD", donationInvoice.Currency);
                 Assert.Equal("donation", donationInvoice.ItemDesc);
@@ -2587,7 +2609,113 @@ donation:
             Assert.Equal(StatusMessageModel.StatusSeverity.Success, parsed.Severity);
 
         }
+        
+        [Fact]
+        [Trait("Integration", "Integration")]
+       public  async Task CanCreateInvoiceWithSpecificPaymentMethods()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                await tester.EnsureChannelsSetup();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterLightningNode("BTC", LightningConnectionType.Charge);
+                user.RegisterDerivationScheme("BTC");
+                user.RegisterDerivationScheme("LTC");
 
+                var invoice = await user.BitPay.CreateInvoiceAsync(new Invoice(100, "BTC"));
+                Assert.Equal(2, invoice.SupportedTransactionCurrencies.Count);
+               
+                
+                invoice = await user.BitPay.CreateInvoiceAsync(new Invoice(100, "BTC")
+                {
+                    SupportedTransactionCurrencies = new Dictionary<string, InvoiceSupportedTransactionCurrency>()
+                    {
+                        {"BTC", new InvoiceSupportedTransactionCurrency()
+                        {
+                            Enabled = true
+                        }}
+                    }
+                });
+                
+                Assert.Single(invoice.SupportedTransactionCurrencies);
+            }
+        }
+        
+
+        
+         [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanLoginWithNoSecondaryAuthSystemsOrRequestItWhenAdded()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+               var accountController = tester.PayTester.GetController<AccountController>();
+
+               //no 2fa or u2f enabled, login should work
+               Assert.Equal(nameof(HomeController.Index), Assert.IsType<RedirectToActionResult>(await accountController.Login(new LoginViewModel()
+               {
+                   Email = user.RegisterDetails.Email,
+                   Password = user.RegisterDetails.Password
+               })).ActionName);
+
+               var manageController = user.GetController<ManageController>();
+               
+               //by default no u2f devices available
+               Assert.Empty(Assert.IsType<U2FAuthenticationViewModel>(Assert.IsType<ViewResult>(await manageController.U2FAuthentication()).Model).Devices);
+               var addRequest = Assert.IsType<AddU2FDeviceViewModel>(Assert.IsType<ViewResult>(manageController.AddU2FDevice("label")).Model);
+               //name should match the one provided in beginning
+               Assert.Equal("label",addRequest.Name);
+               
+               //sending an invalid response model back to server, should error out
+               var statusMessage = Assert
+                   .IsType<RedirectToActionResult>(await manageController.AddU2FDevice(addRequest))
+                   .RouteValues["StatusMessage"].ToString();
+               Assert.NotNull(statusMessage);
+               Assert.Equal(StatusMessageModel.StatusSeverity.Error, new StatusMessageModel(statusMessage).Severity);
+
+               var contextFactory = tester.PayTester.GetService<ApplicationDbContextFactory>();
+
+               //add a fake u2f device in db directly since emulating a u2f device is hard and annoying
+               using (var context = contextFactory.CreateContext())
+               {
+                   var newDevice = new U2FDevice()
+                   {
+                       Name = "fake",
+                       Counter = 0,
+                       KeyHandle = UTF8Encoding.UTF8.GetBytes("fake"),
+                       PublicKey= UTF8Encoding.UTF8.GetBytes("fake"),
+                       AttestationCert= UTF8Encoding.UTF8.GetBytes("fake"),
+                       ApplicationUserId= user.UserId
+                   };
+                   await context.U2FDevices.AddAsync(newDevice);
+                   await context.SaveChangesAsync();
+                   
+                   Assert.NotNull(newDevice.Id);
+                   Assert.NotEmpty(Assert.IsType<U2FAuthenticationViewModel>(Assert.IsType<ViewResult>(await manageController.U2FAuthentication()).Model).Devices);
+                   
+               }
+
+               //check if we are showing the u2f login screen now
+               var secondLoginResult = Assert.IsType<ViewResult>(await accountController.Login(new LoginViewModel()
+               {
+                   Email = user.RegisterDetails.Email,
+                   Password = user.RegisterDetails.Password
+               }));
+
+               Assert.Equal("SecondaryLogin", secondLoginResult.ViewName);
+               var vm = Assert.IsType<SecondaryLoginViewModel>(secondLoginResult.Model);
+               //2fa was never enabled for user so this should be empty
+               Assert.Null(vm.LoginWith2FaViewModel);
+               Assert.NotNull(vm.LoginWithU2FViewModel);               
+            }
+        }
+        
         private static bool IsMapped(Invoice invoice, ApplicationDbContext ctx)
         {
             var h = BitcoinAddress.Create(invoice.BitcoinAddress, Network.RegTest).ScriptPubKey.Hash.ToString();

BTCPayServer.Tests/docker-bitcoin-generate.ps1

@@ -0,0 +1,3 @@
+$bitcoind_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=bitcoind)
+$address=$(docker exec -ti $bitcoind_container_id bitcoin-cli -datadir="/data" getnewaddress)
+docker exec -ti $bitcoind_container_id bitcoin-cli -datadir="/data" generatetoaddress $args $address

BTCPayServer.Tests/docker-compose.yml

@@ -19,6 +19,8 @@ services:
       TESTS_MYSQL: User ID=root;Host=mysql;Port=3306;Database=btcpayserver
       TESTS_PORT: 80
       TESTS_HOSTNAME: tests
+      TESTS_RUN_EXTERNAL_INTEGRATION: ${TESTS_RUN_EXTERNAL_INTEGRATION:-false}
+      TESTS_AzureBlobStorageConnectionString: ${TESTS_AzureBlobStorageConnectionString:-none}
       TEST_MERCHANTLIGHTNINGD: "type=clightning;server=unix://etc/merchant_lightningd_datadir/lightning-rpc"
       TEST_CUSTOMERLIGHTNINGD: "type=clightning;server=unix://etc/customer_lightningd_datadir/lightning-rpc"
       TEST_MERCHANTCHARGE: "type=charge;server=http://lightning-charged:9112/;api-token=foiewnccewuify"
@@ -36,7 +38,7 @@ services:
 
   # The dev container is not actually used, it is just handy to run `docker-compose up dev` to start all services
   dev: 
-    image: btcpayserver/bitcoin:0.17.0
+    image: btcpayserver/bitcoin:0.18.0
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_EXTRA_ARGS: |
@@ -53,7 +55,7 @@ services:
       - merchant_lnd
 
   devlnd: 
-    image: btcpayserver/bitcoin:0.17.0
+    image: btcpayserver/bitcoin:0.18.0
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_EXTRA_ARGS: |
@@ -69,7 +71,7 @@ services:
 
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.0.0.27
+    image: nicolasdorier/nbxplorer:2.0.0.39
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -96,13 +98,14 @@ services:
 
   bitcoind:
     restart: unless-stopped
-    image: btcpayserver/bitcoin:0.17.0
+    image: btcpayserver/bitcoin:0.18.0
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_EXTRA_ARGS: |-
         rpcuser=ceiwHEbqWI83
         rpcpassword=DwubwWsoo3
         rpcport=43782
+        rpcbind=0.0.0.0:43782
         port=39388
         whitelist=0.0.0.0/0
         zmqpubrawblock=tcp://0.0.0.0:28332
@@ -222,7 +225,7 @@ services:
       - MYSQL_ALLOW_EMPTY_PASSWORD=yes
 
   merchant_lnd:
-    image: btcpayserver/lnd:v0.5.2-beta
+    image: btcpayserver/lnd:v0.6-beta
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -252,7 +255,7 @@ services:
       - bitcoind
 
   customer_lnd:
-    image: btcpayserver/lnd:v0.5.2-beta
+    image: btcpayserver/lnd:v0.6-beta
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"

BTCPayServer.Tests/docker-entrypoint.sh

@@ -3,3 +3,6 @@ set -e
 
 dotnet test --filter Fast=Fast --no-build
 dotnet test --filter Integration=Integration --no-build -v n
+if [[ "$TESTS_RUN_EXTERNAL_INTEGRATION" == "true" ]]; then
+    dotnet test --filter ExternalIntegration=ExternalIntegration --no-build -v n
+fi

BTCPayServer/Authentication/TokenRepository.cs

@@ -1,5 +1,5 @@
 using BTCPayServer.Data;
-using DBreeze;
+using DBriize;
 using NBitcoin;
 using NBitcoin.DataEncoders;
 using Newtonsoft.Json;

BTCPayServer/BTCPayNetwork.cs

@@ -64,6 +64,7 @@ namespace BTCPayServer
         public KeyPath CoinType { get; internal set; }
         public int MaxTrackedConfirmation { get; internal set; } = 6;
         public string[] DefaultRateRules { get; internal set; } = Array.Empty<string>();
+        public bool SupportRBF { get; internal set; }
 
         public override string ToString()
         {

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -25,7 +25,8 @@ namespace BTCPayServer
                 CryptoImagePath = "imlegacy/bitcoin.svg",
                 LightningImagePath = "imlegacy/bitcoin-lightning.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'"),
+                SupportRBF = true
             });
         }
     }

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-		<Version>1.0.3.94</Version>
+		<Version>1.0.3.97</Version>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
@@ -34,7 +34,7 @@
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.16" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.18" />
     <PackageReference Include="BuildBundlerMinifier" Version="2.9.406" />
     <PackageReference Include="BundlerMinifier.Core" Version="2.9.406" />
     <PackageReference Include="BundlerMinifier.TagHelpers" Version="2.9.406" />
@@ -47,10 +47,11 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="NBitcoin" Version="4.1.1.98" />
+    <PackageReference Include="NBitcoin" Version="4.1.2.14" />
     <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
-    <PackageReference Include="DBreeze" Version="1.92.0" />
-    <PackageReference Include="NBXplorer.Client" Version="2.0.0.6" />
+    <PackageReference Include="DBriize" Version="1.0.0.4" />
+    <PackageReference Include="NBXplorer.Client" Version="2.0.0.11" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <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" />
@@ -61,7 +62,6 @@
     <PackageReference Include="Serilog.AspNetCore" Version="2.1.1" />
     <PackageReference Include="Serilog.Sinks.File" Version="4.0.0" />
     <PackageReference Include="SSH.NET" Version="2016.1.0" />
-    <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />
     <PackageReference Include="Text.Analyzers" Version="2.6.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
@@ -70,6 +70,12 @@
 
 	<ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <PackageReference Include="TwentyTwenty.Storage" Version="2.10.1" />
+    <PackageReference Include="TwentyTwenty.Storage.Amazon" Version="2.10.1" />
+    <PackageReference Include="TwentyTwenty.Storage.Azure" Version="2.10.1" />
+    <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.10.1" />
+    <PackageReference Include="TwentyTwenty.Storage.Local" Version="2.10.1" />
+    <PackageReference Include="U2F.Core" Version="1.0.4" />
 		<PackageReference Include="YamlDotNet" Version="5.2.1" />
 	</ItemGroup>
 
@@ -125,9 +131,11 @@
 
 	<ItemGroup>
 	  <Folder Include="Build\" />
+	  <Folder Include="U2F\Services" />
 	  <Folder Include="wwwroot\vendor\clipboard.js\" />
 	  <Folder Include="wwwroot\vendor\highlightjs\" />
 	  <Folder Include="wwwroot\vendor\summernote" />
+	  <Folder Include="wwwroot\vendor\u2f" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -144,6 +152,9 @@
     <Content Update="Views\Server\LightningWalletServices.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
+    <Content Update="Views\Server\P2PService.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
     <Content Update="Views\Server\SSHService.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>

BTCPayServer/Configuration/ExternalConnectionString.cs

@@ -8,6 +8,14 @@ namespace BTCPayServer.Configuration
 {
     public class ExternalConnectionString
     {
+        public ExternalConnectionString()
+        {
+
+        }
+        public ExternalConnectionString(Uri server)
+        {
+            Server = server;
+        }
         public Uri Server { get; set; }
         public byte[] Macaroon { get; set; }
         public Macaroons Macaroons { get; set; }

BTCPayServer/Configuration/ExternalService.cs

@@ -75,6 +75,7 @@ namespace BTCPayServer.Configuration
         LNDGRPC,
         Spark,
         RTL,
-        Charge
+        Charge,
+        P2P
     }
 }

BTCPayServer/Controllers/AccountController.cs

@@ -18,6 +18,9 @@ using BTCPayServer.Services.Stores;
 using BTCPayServer.Logging;
 using BTCPayServer.Security;
 using System.Globalization;
+using BTCPayServer.Services.U2F;
+using BTCPayServer.Services.U2F.Models;
+using Newtonsoft.Json;
 using NicolasDorier.RateLimits;
 
 namespace BTCPayServer.Controllers
@@ -33,6 +36,8 @@ namespace BTCPayServer.Controllers
         RoleManager<IdentityRole> _RoleManager;
         SettingsRepository _SettingsRepository;
         Configuration.BTCPayServerOptions _Options;
+        private readonly BTCPayServerEnvironment _btcPayServerEnvironment;
+        private readonly U2FService _u2FService;
         ILogger _logger;
 
         public AccountController(
@@ -42,7 +47,9 @@ namespace BTCPayServer.Controllers
             SignInManager<ApplicationUser> signInManager,
             EmailSenderFactory emailSenderFactory,
             SettingsRepository settingsRepository,
-            Configuration.BTCPayServerOptions options)
+            Configuration.BTCPayServerOptions options,
+            BTCPayServerEnvironment btcPayServerEnvironment,
+            U2FService u2FService)
         {
             this.storeRepository = storeRepository;
             _userManager = userManager;
@@ -51,6 +58,8 @@ namespace BTCPayServer.Controllers
             _RoleManager = roleManager;
             _SettingsRepository = settingsRepository;
             _Options = options;
+            _btcPayServerEnvironment = btcPayServerEnvironment;
+            _u2FService = u2FService;
             _logger = Logs.PayServer;
         }
 
@@ -91,8 +100,44 @@ namespace BTCPayServer.Controllers
                         return View(model);
                     }
                 }
-                // This doesn't count login failures towards account lockout
-                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
+                else
+                {
+                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
+                    return View(model);
+                }
+
+                if (!await _userManager.IsLockedOutAsync(user) && await _u2FService.HasDevices(user.Id))
+                {
+                    if (await _userManager.CheckPasswordAsync(user, model.Password))
+                    {
+                        LoginWith2faViewModel twoFModel = null;
+                        
+                        if (user.TwoFactorEnabled)
+                        {
+                            // we need to do an actual sign in attempt so that 2fa can function in next step
+                            await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: true);
+                            twoFModel = new LoginWith2faViewModel
+                            {
+                                RememberMe = model.RememberMe
+                            };
+                        }
+
+                        return View("SecondaryLogin", new SecondaryLoginViewModel()
+                        {
+                            LoginWith2FaViewModel = twoFModel,
+                            LoginWithU2FViewModel = await BuildU2FViewModel(model.RememberMe, user)
+                        });
+                    }
+                    else
+                    {
+                      var incrementAccessFailedResult = await  _userManager.AccessFailedAsync(user);
+                      ModelState.AddModelError(string.Empty, "Invalid login attempt.");
+                      return View(model);
+                      
+                    }
+                }
+                
+               
                 var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: true);
                 if (result.Succeeded)
                 {
@@ -101,10 +146,12 @@ namespace BTCPayServer.Controllers
                 }
                 if (result.RequiresTwoFactor)
                 {
-                    return RedirectToAction(nameof(LoginWith2fa), new
+                    return View("SecondaryLogin", new SecondaryLoginViewModel()
                     {
-                        returnUrl,
-                        model.RememberMe
+                        LoginWith2FaViewModel = new LoginWith2faViewModel()
+                        {
+                            RememberMe = model.RememberMe
+                        }
                     });
                 }
                 if (result.IsLockedOut)
@@ -123,6 +170,71 @@ namespace BTCPayServer.Controllers
             return View(model);
         }
 
+        private async Task<LoginWithU2FViewModel> BuildU2FViewModel(bool rememberMe, ApplicationUser user)
+        {
+            if (_btcPayServerEnvironment.IsSecure)
+            {
+                var u2fChallenge = await _u2FService.GenerateDeviceChallenges(user.Id,
+                    Request.GetAbsoluteUriNoPathBase().ToString().TrimEnd('/'));
+
+                return new LoginWithU2FViewModel()
+                {
+                    Version = u2fChallenge[0].version,
+                    Challenge = u2fChallenge[0].challenge,
+                    Challenges = JsonConvert.SerializeObject(u2fChallenge),
+                    AppId = u2fChallenge[0].appId,
+                    UserId = user.Id,
+                    RememberMe = rememberMe
+                };
+            }
+
+            return null;
+        }
+
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> LoginWithU2F(LoginWithU2FViewModel viewModel, string returnUrl = null)
+        {
+            ViewData["ReturnUrl"] = returnUrl;
+            var user = await _userManager.FindByIdAsync(viewModel.UserId);
+
+            if (user == null)
+            {
+                return NotFound();
+            }
+
+            var errorMessage = string.Empty;
+            try
+            {
+                if (await _u2FService.AuthenticateUser(viewModel.UserId, viewModel.DeviceResponse))
+                {
+                    await _signInManager.SignInAsync(user, viewModel.RememberMe, "U2F");
+                    _logger.LogInformation("User logged in.");
+                    return RedirectToLocal(returnUrl);
+                }
+
+                errorMessage = "Invalid login attempt.";
+            }
+            catch (Exception e)
+            {
+
+                errorMessage = e.Message;
+            }
+
+            ModelState.AddModelError(string.Empty, errorMessage);
+            return View("SecondaryLogin", new SecondaryLoginViewModel()
+            {
+                LoginWithU2FViewModel = viewModel,
+                LoginWith2FaViewModel = !user.TwoFactorEnabled
+                    ? null
+                    : new LoginWith2faViewModel()
+                    {
+                        RememberMe = viewModel.RememberMe
+                    }
+            });
+        }
+
         [HttpGet]
         [AllowAnonymous]
         public async Task<IActionResult> LoginWith2fa(bool rememberMe, string returnUrl = null)
@@ -135,10 +247,13 @@ namespace BTCPayServer.Controllers
                 throw new ApplicationException($"Unable to load two-factor authentication user.");
             }
 
-            var model = new LoginWith2faViewModel { RememberMe = rememberMe };
             ViewData["ReturnUrl"] = returnUrl;
 
-            return View(model);
+            return View("SecondaryLogin", new SecondaryLoginViewModel()
+            {
+                LoginWith2FaViewModel = new LoginWith2faViewModel { RememberMe = rememberMe },
+                LoginWithU2FViewModel =  (await _u2FService.HasDevices(user.Id))? await BuildU2FViewModel(rememberMe, user): null
+            });
         }
 
         [HttpPost]
@@ -175,7 +290,11 @@ namespace BTCPayServer.Controllers
             {
                 _logger.LogWarning("Invalid authenticator code entered for user with ID {UserId}.", user.Id);
                 ModelState.AddModelError(string.Empty, "Invalid authenticator code.");
-                return View();
+                return View("SecondaryLogin", new SecondaryLoginViewModel()
+                {
+                    LoginWith2FaViewModel = model,
+                    LoginWithU2FViewModel =  (await _u2FService.HasDevices(user.Id))? await BuildU2FViewModel(rememberMe, user): null
+                });
             }
         }
 

BTCPayServer/Controllers/AppsController.Crowdfund.cs

@@ -5,6 +5,7 @@ using System.Text.Encodings.Web;
 using System.Threading.Tasks;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Mails;
 using Microsoft.AspNetCore.Mvc;
 
 namespace BTCPayServer.Controllers
@@ -33,6 +34,7 @@ namespace BTCPayServer.Controllers
             var settings = app.GetSettings<CrowdfundSettings>();
             var vm = new UpdateCrowdfundViewModel()
             {
+                NotificationEmailWarning = !await IsEmailConfigured(app.StoreDataId),
                 Title = settings.Title,
                 Enabled = settings.Enabled,
                 EnforceTargetAmount = settings.EnforceTargetAmount,

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Mails;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 
@@ -90,8 +91,10 @@ namespace BTCPayServer.Controllers
             if (app == null)
                 return NotFound();
             var settings = app.GetSettings<PointOfSaleSettings>();
+          
             var vm = new UpdatePointOfSaleViewModel()
             {
+                NotificationEmailWarning = !await IsEmailConfigured(app.StoreDataId),
                 Id = appId,
                 Title = settings.Title,
                 EnableShoppingCart = settings.EnableShoppingCart,

BTCPayServer/Controllers/AppsController.cs

@@ -7,6 +7,7 @@ using BTCPayServer.Models;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Security;
 using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Mails;
 using BTCPayServer.Services.Rates;
 using Ganss.XSS;
 using Microsoft.AspNetCore.Authorization;
@@ -30,6 +31,7 @@ namespace BTCPayServer.Controllers
             BTCPayNetworkProvider networkProvider,
             CurrencyNameTable currencies,
             HtmlSanitizer htmlSanitizer,
+            EmailSenderFactory emailSenderFactory,
             AppService AppService)
         {
             _UserManager = userManager;
@@ -38,6 +40,7 @@ namespace BTCPayServer.Controllers
             _NetworkProvider = networkProvider;
             _currencies = currencies;
             _htmlSanitizer = htmlSanitizer;
+            _emailSenderFactory = emailSenderFactory;
             _AppService = AppService;
         }
 
@@ -47,6 +50,7 @@ namespace BTCPayServer.Controllers
         private BTCPayNetworkProvider _NetworkProvider;
         private readonly CurrencyNameTable _currencies;
         private readonly HtmlSanitizer _htmlSanitizer;
+        private readonly EmailSenderFactory _emailSenderFactory;
         private AppService _AppService;
 
         [TempData]
@@ -176,5 +180,10 @@ namespace BTCPayServer.Controllers
         {
             return _UserManager.GetUserId(User);
         }
+
+        private async Task<bool> IsEmailConfigured(string storeId)
+        {
+            return (await (_emailSenderFactory.GetEmailSender(storeId) as EmailSender)?.GetEmailSettings())?.IsComplete() is true;
+        }
     }
 }

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -47,9 +47,9 @@ namespace BTCPayServer.Controllers
             if (invoice == null)
                 return NotFound();
 
-            var dto = invoice.EntityToDTO(_NetworkProvider);
+            var prodInfo = invoice.ProductInformation;
             var store = await _StoreRepository.FindStore(invoice.StoreId);
-            InvoiceDetailsModel model = new InvoiceDetailsModel()
+            var model = new InvoiceDetailsModel()
             {
                 StoreName = store.StoreName,
                 StoreLink = Url.Action(nameof(StoresController.UpdateStore), "Stores", new { storeId = store.Id }),
@@ -65,20 +65,62 @@ namespace BTCPayServer.Controllers
                 MonitoringDate = invoice.MonitoringExpiration,
                 OrderId = invoice.OrderId,
                 BuyerInformation = invoice.BuyerInformation,
-                Fiat = _CurrencyNameTable.DisplayFormatCurrency(dto.Price, dto.Currency),
-                TaxIncluded = _CurrencyNameTable.DisplayFormatCurrency(invoice.ProductInformation.TaxIncluded, dto.Currency),
+                Fiat = _CurrencyNameTable.DisplayFormatCurrency(prodInfo.Price, prodInfo.Currency),
+                TaxIncluded = _CurrencyNameTable.DisplayFormatCurrency(prodInfo.TaxIncluded, prodInfo.Currency),
                 NotificationEmail = invoice.NotificationEmail,
                 NotificationUrl = invoice.NotificationURL,
                 RedirectUrl = invoice.RedirectURL,
                 ProductInformation = invoice.ProductInformation,
                 StatusException = invoice.ExceptionStatus,
                 Events = invoice.Events,
-                PosData = PosDataParser.ParsePosData(dto.PosData)
+                PosData = PosDataParser.ParsePosData(invoice.PosData),
+                StatusMessage = StatusMessage
             };
 
+            model.Addresses = invoice.HistoricalAddresses.Select(h => new InvoiceDetailsModel.AddressModel
+            {
+                Destination = h.GetAddress(),
+                PaymentMethod = ToString(h.GetPaymentMethodId()),
+                Current = !h.UnAssigned.HasValue
+            }).ToArray();
+
+            var updateConfirmationCountIfNeeded = invoice
+                .GetPayments()
+                .Select<PaymentEntity, Task>(async payment =>
+                {
+                    var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
+                    var paymentData = payment.GetCryptoPaymentData();
+                    if (paymentData is Payments.Bitcoin.BitcoinLikePaymentData onChainPaymentData)
+                    {
+                        int confirmationCount = 0;
+                        if ((onChainPaymentData.ConfirmationCount < paymentNetwork.MaxTrackedConfirmation && payment.Accounted)
+                             && (onChainPaymentData.Legacy || invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
+                        // The confirmation count in the paymentData is not up to date
+                        {
+                            confirmationCount = (await ((ExplorerClientProvider)_ServiceProvider.GetService(typeof(ExplorerClientProvider))).GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(onChainPaymentData.Outpoint.Hash))?.Confirmations ?? 0;
+                            onChainPaymentData.ConfirmationCount = confirmationCount;
+                            payment.SetCryptoPaymentData(onChainPaymentData);
+                            await _InvoiceRepository.UpdatePayments(new List<PaymentEntity> { payment });
+                        }
+                    }
+                })
+                .ToArray();
+            await Task.WhenAll(updateConfirmationCountIfNeeded);
+
+            var details = InvoicePopulatePayments(invoice);
+            model.CryptoPayments = details.CryptoPayments;
+            model.OnChainPayments = details.OnChainPayments;
+            model.OffChainPayments = details.OffChainPayments;
+
+            return View(model);
+        }
+
+        private InvoiceDetailsModel InvoicePopulatePayments(InvoiceEntity invoice)
+        {
+            var model = new InvoiceDetailsModel();
+
             foreach (var data in invoice.GetPaymentMethods(null))
             {
-                var cryptoInfo = dto.CryptoInfo.First(o => o.GetpaymentMethodId() == data.GetId());
                 var accounting = data.Calculate();
                 var paymentMethodId = data.GetId();
                 var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
@@ -93,72 +135,46 @@ namespace BTCPayServer.Controllers
                     cryptoPayment.Address = onchainMethod.DepositAddress;
                 }
                 cryptoPayment.Rate = ExchangeRate(data);
-                cryptoPayment.PaymentUrl = cryptoInfo.PaymentUrls.BIP21;
                 model.CryptoPayments.Add(cryptoPayment);
             }
 
-            var onChainPayments = invoice
-                .GetPayments()
-                .Select<PaymentEntity, Task<object>>(async payment =>
+            foreach (var payment in invoice.GetPayments())
+            {
+                var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
+                var paymentData = payment.GetCryptoPaymentData();
+                if (paymentData is Payments.Bitcoin.BitcoinLikePaymentData onChainPaymentData)
                 {
-                    var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
-                    var paymentData = payment.GetCryptoPaymentData();
-                    if (paymentData is Payments.Bitcoin.BitcoinLikePaymentData onChainPaymentData)
+                    var m = new InvoiceDetailsModel.Payment();
+                    m.Crypto = payment.GetPaymentMethodId().CryptoCode;
+                    m.DepositAddress = onChainPaymentData.GetDestination(paymentNetwork);
+
+                    int confirmationCount = onChainPaymentData.ConfirmationCount;
+                    if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
                     {
-                        var m = new InvoiceDetailsModel.Payment();
-                        m.Crypto = payment.GetPaymentMethodId().CryptoCode;
-                        m.DepositAddress = onChainPaymentData.GetDestination(paymentNetwork);
-
-                        int confirmationCount = 0;
-                        if ((onChainPaymentData.ConfirmationCount < paymentNetwork.MaxTrackedConfirmation && payment.Accounted)
-                             && (onChainPaymentData.Legacy || invoice.MonitoringExpiration < DateTimeOffset.UtcNow)) // The confirmation count in the paymentData is not up to date
-                        {
-                            confirmationCount = (await ((ExplorerClientProvider)_ServiceProvider.GetService(typeof(ExplorerClientProvider))).GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(onChainPaymentData.Outpoint.Hash))?.Confirmations ?? 0;
-                            onChainPaymentData.ConfirmationCount = confirmationCount;
-                            payment.SetCryptoPaymentData(onChainPaymentData);
-                            await _InvoiceRepository.UpdatePayments(new List<PaymentEntity> { payment });
-                        }
-                        else
-                        {
-                            confirmationCount = onChainPaymentData.ConfirmationCount;
-                        }
-                        if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
-                        {
-                            m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
-                        }
-                        else
-                        {
-                            m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
-                        }
-
-                        m.TransactionId = onChainPaymentData.Outpoint.Hash.ToString();
-                        m.ReceivedTime = payment.ReceivedTime;
-                        m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
-                        m.Replaced = !payment.Accounted;
-                        return m;
+                        m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
                     }
                     else
                     {
-                        var lightningPaymentData = (Payments.Lightning.LightningLikePaymentData)paymentData;
-                        return new InvoiceDetailsModel.OffChainPayment()
-                        {
-                            Crypto = paymentNetwork.CryptoCode,
-                            BOLT11 = lightningPaymentData.BOLT11
-                        };
+                        m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
                     }
-                })
-                .ToArray();
-            await Task.WhenAll(onChainPayments);
-            model.Addresses = invoice.HistoricalAddresses.Select(h => new InvoiceDetailsModel.AddressModel
-            {
-                Destination = h.GetAddress(),
-                PaymentMethod = ToString(h.GetPaymentMethodId()),
-                Current = !h.UnAssigned.HasValue
-            }).ToArray();
-            model.OnChainPayments = onChainPayments.Select(p => p.GetAwaiter().GetResult()).OfType<InvoiceDetailsModel.Payment>().ToList();
-            model.OffChainPayments = onChainPayments.Select(p => p.GetAwaiter().GetResult()).OfType<InvoiceDetailsModel.OffChainPayment>().ToList();
-            model.StatusMessage = StatusMessage;
-            return View(model);
+
+                    m.TransactionId = onChainPaymentData.Outpoint.Hash.ToString();
+                    m.ReceivedTime = payment.ReceivedTime;
+                    m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
+                    m.Replaced = !payment.Accounted;
+                    model.OnChainPayments.Add(m);
+                }
+                else
+                {
+                    var lightningPaymentData = (LightningLikePaymentData)paymentData;
+                    model.OffChainPayments.Add(new InvoiceDetailsModel.OffChainPayment()
+                    {
+                        Crypto = paymentNetwork.CryptoCode,
+                        BOLT11 = lightningPaymentData.BOLT11
+                    });
+                }
+            }
+            return model;
         }
 
         private string ToString(PaymentMethodId paymentMethodId)
@@ -276,7 +292,7 @@ namespace BTCPayServer.Controllers
                                            storeBlob.ChangellySettings.IsConfigured())
                 ? storeBlob.ChangellySettings
                 : null;
-            
+
             CoinSwitchSettings coinswitch = (storeBlob.CoinSwitchSettings != null && storeBlob.CoinSwitchSettings.Enabled &&
                                            storeBlob.CoinSwitchSettings.IsConfigured())
                 ? storeBlob.CoinSwitchSettings
@@ -335,7 +351,7 @@ namespace BTCPayServer.Controllers
                 ChangellyMerchantId = changelly?.ChangellyMerchantId,
                 ChangellyAmountDue = changellyAmountDue,
                 CoinSwitchEnabled = coinswitch != null,
-                CoinSwitchAmountMarkupPercentage = coinswitch?.AmountMarkupPercentage?? 0,
+                CoinSwitchAmountMarkupPercentage = coinswitch?.AmountMarkupPercentage ?? 0,
                 CoinSwitchMerchantId = coinswitch?.MerchantId,
                 CoinSwitchMode = coinswitch?.Mode,
                 StoreId = store.Id,
@@ -410,7 +426,7 @@ namespace BTCPayServer.Controllers
             if (!HttpContext.WebSockets.IsWebSocketRequest)
                 return NotFound();
             var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
-            if (invoice == null || invoice.Status == InvoiceStatus.Complete || invoice.Status ==  InvoiceStatus.Invalid || invoice.Status == InvoiceStatus.Expired)
+            if (invoice == null || invoice.Status == InvoiceStatus.Complete || invoice.Status == InvoiceStatus.Invalid || invoice.Status == InvoiceStatus.Expired)
                 return NotFound();
             var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
             CompositeDisposable leases = new CompositeDisposable();
@@ -465,31 +481,29 @@ namespace BTCPayServer.Controllers
         [Route("invoices")]
         [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
-        public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 50)
+        public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 50, int timezoneOffset = 0)
         {
-            if (searchTerm == null)
-            {
-                searchTerm = HttpContext.Session.GetString("InvoicesSearchTerm");
-            }
             var model = new InvoicesModel
             {
                 SearchTerm = searchTerm,
                 Skip = skip,
                 Count = count,
-                StatusMessage = StatusMessage
+                StatusMessage = StatusMessage,
+                TimezoneOffset = timezoneOffset
             };
-            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm);
+            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm, timezoneOffset);
             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();
                 model.Invoices.Add(new InvoiceModel()
                 {
-                    Status = state.ToString(),
+                    Status = invoice.Status,
+                    StatusString = state.ToString(),
                     ShowCheckout = invoice.Status == InvoiceStatus.New,
                     Date = invoice.InvoiceTime,
                     InvoiceId = invoice.Id,
@@ -497,28 +511,29 @@ namespace BTCPayServer.Controllers
                     RedirectUrl = invoice.RedirectURL ?? string.Empty,
                     AmountCurrency = _CurrencyNameTable.DisplayFormatCurrency(invoice.ProductInformation.Price, invoice.ProductInformation.Currency),
                     CanMarkInvalid = state.CanMarkInvalid(),
-                    CanMarkComplete = state.CanMarkComplete()
+                    CanMarkComplete = state.CanMarkComplete(),
+                    Details = InvoicePopulatePayments(invoice)
                 });
             }
             model.Total = await counting;
             return View(model);
         }
 
-        private InvoiceQuery GetInvoiceQuery(string searchTerm = null)
+        private InvoiceQuery GetInvoiceQuery(string searchTerm = null, int timezoneOffset = 0)
         {
-            var filterString = new SearchString(searchTerm);
+            var fs = new SearchString(searchTerm);
             var invoiceQuery = new InvoiceQuery()
             {
-                TextSearch = filterString.TextSearch,
+                TextSearch = fs.TextSearch,
                 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,
-                ItemCode = filterString.Filters.ContainsKey("itemcode") ? filterString.Filters["itemcode"].ToArray() : null,
-                OrderId = filterString.Filters.ContainsKey("orderid") ? filterString.Filters["orderid"].ToArray() : null
+                Unusual = fs.GetFilterBool("unusual"),
+                Status = fs.GetFilterArray("status"),
+                ExceptionStatus = fs.GetFilterArray("exceptionstatus"),
+                StoreId = fs.GetFilterArray("storeid"),
+                ItemCode = fs.GetFilterArray("itemcode"),
+                OrderId = fs.GetFilterArray("orderid"),
+                StartDate = fs.GetFilterDate("startdate", timezoneOffset),
+                EndDate = fs.GetFilterDate("enddate", timezoneOffset)
             };
             return invoiceQuery;
         }
@@ -526,13 +541,13 @@ namespace BTCPayServer.Controllers
         [HttpGet]
         [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
-        public async Task<IActionResult> Export(string format, string searchTerm = null)
+        public async Task<IActionResult> Export(string format, string searchTerm = null, int timezoneOffset = 0)
         {
             var model = new InvoiceExport(_NetworkProvider, _CurrencyNameTable);
 
-            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm);
-            invoiceQuery.Count = int.MaxValue;
+            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm, timezoneOffset);
             invoiceQuery.Skip = 0;
+            invoiceQuery.Count = int.MaxValue;
             var invoices = await _InvoiceRepository.GetInvoices(invoiceQuery);
             var res = model.Process(invoices, format);
 
@@ -560,7 +575,16 @@ namespace BTCPayServer.Controllers
                 StatusMessage = "Error: You need to create at least one store before creating a transaction";
                 return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
             }
-            return View(new CreateInvoiceModel() { Stores = stores });
+
+            var paymentMethods = new SelectList(_NetworkProvider.GetAll().SelectMany(network => new[]
+                                                         {
+                                                             new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike),
+                                                             new PaymentMethodId(network.CryptoCode, PaymentTypes.LightningLike)
+                                                         }).Select(id => new SelectListItem(id.ToString(true), id.ToString(false))),
+                                                             nameof(SelectListItem.Value),
+                                                             nameof(SelectListItem.Text));
+
+            return View(new CreateInvoiceModel() { Stores = stores, AvailablePaymentMethods = paymentMethods });
         }
 
         [HttpPost]
@@ -571,6 +595,16 @@ namespace BTCPayServer.Controllers
         {
             var stores = await _StoreRepository.GetStoresByUserId(GetUserId());
             model.Stores = new SelectList(stores, nameof(StoreData.Id), nameof(StoreData.StoreName), model.StoreId);
+
+            var paymentMethods = new SelectList(_NetworkProvider.GetAll().SelectMany(network => new[]
+                {
+                    new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike),
+                    new PaymentMethodId(network.CryptoCode, PaymentTypes.LightningLike)
+                }).Select(id => new SelectListItem(id.ToString(true), id.ToString(false))),
+                nameof(SelectListItem.Value),
+                nameof(SelectListItem.Text));
+            model.AvailablePaymentMethods = paymentMethods;
+
             var store = stores.FirstOrDefault(s => s.Id == model.StoreId);
             if (store == null)
             {
@@ -593,6 +627,7 @@ namespace BTCPayServer.Controllers
                 return View(model);
             }
 
+
             if (StatusMessage != null)
             {
                 return RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
@@ -615,6 +650,10 @@ namespace BTCPayServer.Controllers
                     ItemDesc = model.ItemDesc,
                     FullNotifications = true,
                     BuyerEmail = model.BuyerEmail,
+                    SupportedTransactionCurrencies = model.SupportedTransactionCurrencies?.ToDictionary(s => s, s => new InvoiceSupportedTransactionCurrency()
+                    {
+                        Enabled = true
+                    })
                 }, store, HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
 
                 StatusMessage = $"Invoice {result.Data.Id} just created!";
@@ -628,81 +667,45 @@ namespace BTCPayServer.Controllers
         }
 
         [HttpPost]
-        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
-        [BitpayAPIConstraint(false)]
-        public IActionResult SearchInvoice(InvoicesModel invoices)
-        {
-            if (invoices.SearchTerm == null)
-            {
-                HttpContext.Session.Remove("InvoicesSearchTerm");
-            }
-            else
-            {
-                HttpContext.Session.SetString("InvoicesSearchTerm", invoices.SearchTerm);  
-            } 
-            return RedirectToAction(nameof(ListInvoices), new
-            {
-                searchTerm = invoices.SearchTerm,
-                skip = invoices.Skip,
-                count = invoices.Count,
-            });
-        }
-
-        [HttpGet]
         [Route("invoices/{invoiceId}/changestate/{newState}")]
         [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
-        public IActionResult ChangeInvoiceState(string invoiceId, string newState)
-        {
-            if (newState == "invalid")
-            {
-                return View("Confirm", new ConfirmModel()
-                {
-                    Action = "Make invoice invalid",
-                    Title = "Change invoice state",
-                    Description = $"You will transition the state of this invoice to \"invalid\", do you want to continue?",
-                });
-            }
-            else if (newState == "complete")
-            {
-                return View("Confirm", new ConfirmModel()
-                {
-                    Action = "Make invoice complete",
-                    Title = "Change invoice state",
-                    Description = $"You will transition the state of this invoice to \"complete\", do you want to continue?",
-                    ButtonClass = "btn-primary"
-                });
-            }
-            else
-                return NotFound();
-        }
-
-        [HttpPost]
-        [Route("invoices/{invoiceId}/changestate/{newState}")]
-        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
-        [BitpayAPIConstraint(false)]
-        public async Task<IActionResult> ChangeInvoiceStateConfirm(string invoiceId, string newState)
+        public async Task<IActionResult> ChangeInvoiceState(string invoiceId, string newState)
         {
             var invoice = (await _InvoiceRepository.GetInvoices(new InvoiceQuery()
             {
                 InvoiceId = invoiceId,
                 UserId = GetUserId()
             })).FirstOrDefault();
+
+            var model = new InvoiceStateChangeModel();
             if (invoice == null)
-                return NotFound();
+            {
+                model.NotFound = true;
+                return NotFound(model);
+            }
+
+
             if (newState == "invalid")
             {
                 await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
                 _EventAggregator.Publish(new InvoiceEvent(invoice, 1008, InvoiceEvent.MarkedInvalid));
-                StatusMessage = "Invoice marked invalid";
+                model.StatusString = new InvoiceState("invalid", "marked").ToString();
             }
-            else if(newState == "complete")
+            else if (newState == "complete")
             {
                 await _InvoiceRepository.UpdatePaidInvoiceToComplete(invoiceId);
                 _EventAggregator.Publish(new InvoiceEvent(invoice, 2008, InvoiceEvent.MarkedCompleted));
-                StatusMessage = "Invoice marked complete";
+                model.StatusString = new InvoiceState("complete", "marked").ToString();
             }
-            return RedirectToAction(nameof(ListInvoices));
+
+            return Json(model);
+        }
+
+        public class InvoiceStateChangeModel
+        {
+            public bool NotFound { get; set; }
+            public string StatusString { get; set; }
         }
 
         [TempData]
@@ -721,18 +724,18 @@ namespace BTCPayServer.Controllers
         {
             public static Dictionary<string, object> ParsePosData(string posData)
             {
-                var result = new Dictionary<string,object>();
+                var result = new Dictionary<string, object>();
                 if (string.IsNullOrEmpty(posData))
                 {
                     return result;
                 }
-            
+
                 try
                 {
-                    var jObject =JObject.Parse(posData);
+                    var jObject = JObject.Parse(posData);
                     foreach (var item in jObject)
                     {
-                    
+
                         switch (item.Value.Type)
                         {
                             case JTokenType.Array:
@@ -749,7 +752,7 @@ namespace BTCPayServer.Controllers
                                 result.Add(item.Key, item.Value.ToString());
                                 break;
                         }
-                    
+
                     }
                 }
                 catch
@@ -759,6 +762,6 @@ namespace BTCPayServer.Controllers
                 return result;
             }
         }
-        
+
     }
 }

BTCPayServer/Controllers/InvoiceController.cs

@@ -160,7 +160,6 @@ namespace BTCPayServer.Controllers
 
             var rateRules = storeBlob.GetRateRules(_NetworkProvider);
             var fetchingByCurrencyPair = _RateProvider.FetchRates(currencyPairsToFetch, rateRules, cancellationToken);
-
             var fetchingAll = WhenAllFetched(logs, fetchingByCurrencyPair);
             var supportedPaymentMethods = store.GetSupportedPaymentMethods(_NetworkProvider)
                                                .Where(s => !excludeFilter.Match(s.PaymentId))

BTCPayServer/Controllers/ManageController.2FA.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Models.ManageViewModels;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class ManageController
+    {
+        private const string AuthenicatorUriFormat = "otpauth://totp/{0}:{1}?secret={2}&issuer={0}&digits=6";
+
+        [HttpGet]
+        public async Task<IActionResult> TwoFactorAuthentication()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var model = new TwoFactorAuthenticationViewModel
+            {
+                HasAuthenticator = await _userManager.GetAuthenticatorKeyAsync(user) != null,
+                Is2faEnabled = user.TwoFactorEnabled,
+                RecoveryCodesLeft = await _userManager.CountRecoveryCodesAsync(user),
+            };
+
+            return View(model);
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> Disable2faWarning()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            if (!user.TwoFactorEnabled)
+            {
+                throw new ApplicationException(
+                    $"Unexpected error occurred disabling 2FA for user with ID '{user.Id}'.");
+            }
+
+            return View(nameof(Disable2fa));
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Disable2fa()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false);
+            if (!disable2faResult.Succeeded)
+            {
+                throw new ApplicationException(
+                    $"Unexpected error occurred disabling 2FA for user with ID '{user.Id}'.");
+            }
+
+            _logger.LogInformation("User with ID {UserId} has disabled 2fa.", user.Id);
+            return RedirectToAction(nameof(TwoFactorAuthentication));
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> EnableAuthenticator()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
+            if (string.IsNullOrEmpty(unformattedKey))
+            {
+                await _userManager.ResetAuthenticatorKeyAsync(user);
+                unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
+            }
+
+            var model = new EnableAuthenticatorViewModel
+            {
+                SharedKey = FormatKey(unformattedKey),
+                AuthenticatorUri = GenerateQrCodeUri(user.Email, unformattedKey)
+            };
+
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> EnableAuthenticator(EnableAuthenticatorViewModel model)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            // Strip spaces and hypens
+            var verificationCode = model.Code.Replace(" ", string.Empty, StringComparison.InvariantCulture)
+                .Replace("-", string.Empty, StringComparison.InvariantCulture);
+
+            var is2faTokenValid = await _userManager.VerifyTwoFactorTokenAsync(
+                user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
+
+            if (!is2faTokenValid)
+            {
+                ModelState.AddModelError(nameof(model.Code), "Verification code is invalid.");
+                return View(model);
+            }
+
+            await _userManager.SetTwoFactorEnabledAsync(user, true);
+            _logger.LogInformation("User with ID {UserId} has enabled 2FA with an authenticator app.", user.Id);
+            return RedirectToAction(nameof(GenerateRecoveryCodes));
+        }
+
+        [HttpGet]
+        public IActionResult ResetAuthenticatorWarning()
+        {
+            return View(nameof(ResetAuthenticator));
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> ResetAuthenticator()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            await _userManager.SetTwoFactorEnabledAsync(user, false);
+            await _userManager.ResetAuthenticatorKeyAsync(user);
+            _logger.LogInformation("User with id '{UserId}' has reset their authentication app key.", user.Id);
+
+            return RedirectToAction(nameof(EnableAuthenticator));
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GenerateRecoveryCodes()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            if (!user.TwoFactorEnabled)
+            {
+                throw new ApplicationException(
+                    $"Cannot generate recovery codes for user with ID '{user.Id}' as they do not have 2FA enabled.");
+            }
+
+            var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
+            var model = new GenerateRecoveryCodesViewModel {RecoveryCodes = recoveryCodes.ToArray()};
+
+            _logger.LogInformation("User with ID {UserId} has generated new 2FA recovery codes.", user.Id);
+
+            return View(model);
+        }
+
+        private string GenerateQrCodeUri(string email, string unformattedKey)
+        {
+            return string.Format(CultureInfo.InvariantCulture,
+                AuthenicatorUriFormat,
+                _urlEncoder.Encode("BTCPayServer"),
+                _urlEncoder.Encode(email),
+                unformattedKey);
+        }
+
+        private string FormatKey(string unformattedKey)
+        {
+            var result = new StringBuilder();
+            int currentPosition = 0;
+            while (currentPosition + 4 < unformattedKey.Length)
+            {
+                result.Append(unformattedKey.Substring(currentPosition, 4)).Append(" ");
+                currentPosition += 4;
+            }
+
+            if (currentPosition < unformattedKey.Length)
+            {
+                result.Append(unformattedKey.Substring(currentPosition));
+            }
+
+            return result.ToString().ToLowerInvariant();
+        }
+    }
+}

BTCPayServer/Controllers/ManageController.U2F.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Threading.Tasks;
+using BTCPayServer.Models;
+using BTCPayServer.Services.U2F.Models;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class ManageController
+    {
+        [HttpGet]
+        public async Task<IActionResult> U2FAuthentication(string statusMessage = null)
+        {
+            return View(new U2FAuthenticationViewModel()
+            {
+                StatusMessage = statusMessage,
+                Devices = await _u2FService.GetDevices(_userManager.GetUserId(User))
+            });
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> RemoveU2FDevice(string id)
+        {
+            await _u2FService.RemoveDevice(id, _userManager.GetUserId(User));
+            return RedirectToAction("U2FAuthentication", new
+            {
+                StatusMessage = "Device removed"
+            });
+        }
+
+        [HttpGet]
+        public IActionResult AddU2FDevice(string name)
+        {
+            if (!_btcPayServerEnvironment.IsSecure)
+            {
+                return RedirectToAction("U2FAuthentication", new
+                {
+                    StatusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = "Cannot register U2F device while not on https or tor"
+                    }
+                });
+            }
+
+            var serverRegisterResponse = _u2FService.StartDeviceRegistration(_userManager.GetUserId(User),
+                Request.GetAbsoluteUriNoPathBase().ToString().TrimEnd('/'));
+
+            return View(new AddU2FDeviceViewModel()
+            {
+                AppId = serverRegisterResponse.AppId,
+                Challenge = serverRegisterResponse.Challenge,
+                Version = serverRegisterResponse.Version,
+                Name = name
+            });
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> AddU2FDevice(AddU2FDeviceViewModel viewModel)
+        {
+            var errorMessage = string.Empty;
+            try
+            {
+                if (await _u2FService.CompleteRegistration(_userManager.GetUserId(User), viewModel.DeviceResponse,
+                    string.IsNullOrEmpty(viewModel.Name) ? "Unlabelled U2F Device" : viewModel.Name))
+                {
+                    return RedirectToAction("U2FAuthentication", new
+                        
+                    {
+                        StatusMessage = "Device added!"
+                    });
+                }
+            }
+            catch (Exception e)
+            {
+                errorMessage = e.Message;
+            }
+
+            return RedirectToAction("U2FAuthentication", new
+            {
+                StatusMessage = new StatusMessageModel()
+                {
+                    Severity = StatusMessageModel.StatusSeverity.Error,
+                    Message = string.IsNullOrEmpty(errorMessage) ? "Could not add device." : errorMessage
+                }
+            });
+        }
+    }
+}

BTCPayServer/Controllers/ManageController.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Text.Encodings.Web;
@@ -9,25 +8,23 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using BTCPayServer.Models;
 using BTCPayServer.Models.ManageViewModels;
 using BTCPayServer.Services;
 using BTCPayServer.Authentication;
 using Microsoft.AspNetCore.Hosting;
-using NBitpayClient;
-using NBitcoin;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
 using BTCPayServer.Services.Mails;
 using System.Globalization;
 using BTCPayServer.Security;
+using BTCPayServer.Services.U2F;
 
 namespace BTCPayServer.Controllers
 {
     [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
     [Route("[controller]/[action]")]
-    public class ManageController : Controller
+    public partial class ManageController : Controller
     {
         private readonly UserManager<ApplicationUser> _userManager;
         private readonly SignInManager<ApplicationUser> _signInManager;
@@ -36,10 +33,11 @@ namespace BTCPayServer.Controllers
         private readonly UrlEncoder _urlEncoder;
         TokenRepository _TokenRepository;
         IHostingEnvironment _Env;
+        private readonly U2FService _u2FService;
+        private readonly BTCPayServerEnvironment _btcPayServerEnvironment;
         StoreRepository _StoreRepository;
 
 
-        private const string AuthenicatorUriFormat = "otpauth://totp/{0}:{1}?secret={2}&issuer={0}&digits=6";
 
         public ManageController(
           UserManager<ApplicationUser> userManager,
@@ -50,7 +48,9 @@ namespace BTCPayServer.Controllers
           TokenRepository tokenRepository,
           BTCPayWalletProvider walletProvider,
           StoreRepository storeRepository,
-          IHostingEnvironment env)
+          IHostingEnvironment env, 
+          U2FService  u2FService,
+          BTCPayServerEnvironment btcPayServerEnvironment)
         {
             _userManager = userManager;
             _signInManager = signInManager;
@@ -59,6 +59,8 @@ namespace BTCPayServer.Controllers
             _urlEncoder = urlEncoder;
             _TokenRepository = tokenRepository;
             _Env = env;
+            _u2FService = u2FService;
+            _btcPayServerEnvironment = btcPayServerEnvironment;
             _StoreRepository = storeRepository;
         }
 
@@ -339,163 +341,6 @@ namespace BTCPayServer.Controllers
             return RedirectToAction(nameof(ExternalLogins));
         }
 
-        [HttpGet]
-        public async Task<IActionResult> TwoFactorAuthentication()
-        {
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            var model = new TwoFactorAuthenticationViewModel
-            {
-                HasAuthenticator = await _userManager.GetAuthenticatorKeyAsync(user) != null,
-                Is2faEnabled = user.TwoFactorEnabled,
-                RecoveryCodesLeft = await _userManager.CountRecoveryCodesAsync(user),
-            };
-
-            return View(model);
-        }
-
-        [HttpGet]
-        public async Task<IActionResult> Disable2faWarning()
-        {
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            if (!user.TwoFactorEnabled)
-            {
-                throw new ApplicationException($"Unexpected error occurred disabling 2FA for user with ID '{user.Id}'.");
-            }
-
-            return View(nameof(Disable2fa));
-        }
-
-        [HttpPost]
-        [ValidateAntiForgeryToken]
-        public async Task<IActionResult> Disable2fa()
-        {
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false);
-            if (!disable2faResult.Succeeded)
-            {
-                throw new ApplicationException($"Unexpected error occurred disabling 2FA for user with ID '{user.Id}'.");
-            }
-
-            _logger.LogInformation("User with ID {UserId} has disabled 2fa.", user.Id);
-            return RedirectToAction(nameof(TwoFactorAuthentication));
-        }
-
-        [HttpGet]
-        public async Task<IActionResult> EnableAuthenticator()
-        {
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
-            if (string.IsNullOrEmpty(unformattedKey))
-            {
-                await _userManager.ResetAuthenticatorKeyAsync(user);
-                unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
-            }
-
-            var model = new EnableAuthenticatorViewModel
-            {
-                SharedKey = FormatKey(unformattedKey),
-                AuthenticatorUri = GenerateQrCodeUri(user.Email, unformattedKey)
-            };
-
-            return View(model);
-        }
-
-        [HttpPost]
-        [ValidateAntiForgeryToken]
-        public async Task<IActionResult> EnableAuthenticator(EnableAuthenticatorViewModel model)
-        {
-            if (!ModelState.IsValid)
-            {
-                return View(model);
-            }
-
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            // Strip spaces and hypens
-            var verificationCode = model.Code.Replace(" ", string.Empty, StringComparison.InvariantCulture).Replace("-", string.Empty, StringComparison.InvariantCulture);
-
-            var is2faTokenValid = await _userManager.VerifyTwoFactorTokenAsync(
-                user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
-
-            if (!is2faTokenValid)
-            {
-                ModelState.AddModelError(nameof(model.Code), "Verification code is invalid.");
-                return View(model);
-            }
-
-            await _userManager.SetTwoFactorEnabledAsync(user, true);
-            _logger.LogInformation("User with ID {UserId} has enabled 2FA with an authenticator app.", user.Id);
-            return RedirectToAction(nameof(GenerateRecoveryCodes));
-        }
-
-        [HttpGet]
-        public IActionResult ResetAuthenticatorWarning()
-        {
-            return View(nameof(ResetAuthenticator));
-        }
-
-        [HttpPost]
-        [ValidateAntiForgeryToken]
-        public async Task<IActionResult> ResetAuthenticator()
-        {
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            await _userManager.SetTwoFactorEnabledAsync(user, false);
-            await _userManager.ResetAuthenticatorKeyAsync(user);
-            _logger.LogInformation("User with id '{UserId}' has reset their authentication app key.", user.Id);
-
-            return RedirectToAction(nameof(EnableAuthenticator));
-        }
-
-        [HttpGet]
-        public async Task<IActionResult> GenerateRecoveryCodes()
-        {
-            var user = await _userManager.GetUserAsync(User);
-            if (user == null)
-            {
-                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-            }
-
-            if (!user.TwoFactorEnabled)
-            {
-                throw new ApplicationException($"Cannot generate recovery codes for user with ID '{user.Id}' as they do not have 2FA enabled.");
-            }
-
-            var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
-            var model = new GenerateRecoveryCodesViewModel { RecoveryCodes = recoveryCodes.ToArray() };
-
-            _logger.LogInformation("User with ID {UserId} has generated new 2FA recovery codes.", user.Id);
-
-            return View(model);
-        }
 
         #region Helpers
 
@@ -506,33 +351,6 @@ namespace BTCPayServer.Controllers
                 ModelState.AddModelError(string.Empty, error.Description);
             }
         }
-
-        private string FormatKey(string unformattedKey)
-        {
-            var result = new StringBuilder();
-            int currentPosition = 0;
-            while (currentPosition + 4 < unformattedKey.Length)
-            {
-                result.Append(unformattedKey.Substring(currentPosition, 4)).Append(" ");
-                currentPosition += 4;
-            }
-            if (currentPosition < unformattedKey.Length)
-            {
-                result.Append(unformattedKey.Substring(currentPosition));
-            }
-
-            return result.ToString().ToLowerInvariant();
-        }
-
-        private string GenerateQrCodeUri(string email, string unformattedKey)
-        {
-            return string.Format(CultureInfo.InvariantCulture,
-                AuthenicatorUriFormat,
-                _urlEncoder.Encode("BTCPayServer"),
-                _urlEncoder.Encode(email),
-                unformattedKey);
-        }
-
         #endregion
     }
 }

BTCPayServer/Controllers/PaymentRequestController.cs

@@ -6,6 +6,7 @@ using System.Security.Claims;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
+using BTCPayServer.Events;
 using BTCPayServer.Filters;
 using BTCPayServer.Models;
 using BTCPayServer.Models.PaymentRequestViewModels;
@@ -41,6 +42,7 @@ namespace BTCPayServer.Controllers
         private readonly EventAggregator _EventAggregator;
         private readonly CurrencyNameTable _Currencies;
         private readonly HtmlSanitizer _htmlSanitizer;
+        private readonly InvoiceRepository _InvoiceRepository;
 
         public PaymentRequestController(
             InvoiceController invoiceController,
@@ -50,7 +52,8 @@ namespace BTCPayServer.Controllers
             PaymentRequestService paymentRequestService,
             EventAggregator eventAggregator,
             CurrencyNameTable currencies,
-            HtmlSanitizer htmlSanitizer)
+            HtmlSanitizer htmlSanitizer,
+            InvoiceRepository invoiceRepository)
         {
             _InvoiceController = invoiceController;
             _UserManager = userManager;
@@ -60,6 +63,7 @@ namespace BTCPayServer.Controllers
             _EventAggregator = eventAggregator;
             _Currencies = currencies;
             _htmlSanitizer = htmlSanitizer;
+            _InvoiceRepository = invoiceRepository;
         }
 
         [HttpGet]
@@ -212,7 +216,7 @@ namespace BTCPayServer.Controllers
         [HttpGet]
         [Route("{id}")]
         [AllowAnonymous]
-        public async Task<IActionResult> ViewPaymentRequest(string id)
+        public async Task<IActionResult> ViewPaymentRequest(string id, string statusMessage = null)
         {
             var result = await _PaymentRequestService.GetPaymentRequest(id, GetUserId());
             if (result == null)
@@ -220,6 +224,8 @@ namespace BTCPayServer.Controllers
                 return NotFound();
             }
             result.HubPath = PaymentRequestHub.GetHubPath(this.Request);
+            result.StatusMessage = statusMessage;
+            
             return View(result);
         }
 
@@ -313,7 +319,39 @@ namespace BTCPayServer.Controllers
             }
         }
 
+        [HttpGet]
+        [Route("{id}/cancel")]
+        public async Task<IActionResult> CancelUnpaidPendingInvoice(string id, bool redirect = true)
+        {
+            var result = await _PaymentRequestService.GetPaymentRequest(id, GetUserId());
+            if (result == null )
+            {
+                return NotFound();
+            }
 
+            var invoice = result.Invoices.SingleOrDefault(requestInvoice =>
+                requestInvoice.Status.Equals(InvoiceState.ToString(InvoiceStatus.New),StringComparison.InvariantCulture) && !requestInvoice.Payments.Any());
+
+            if (invoice == null )
+            {
+                return BadRequest("No unpaid pending invoice to cancel");
+            }
+            
+            await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoice.Id);
+            _EventAggregator.Publish(new InvoiceEvent(await _InvoiceRepository.GetInvoice(invoice.Id), 1008, InvoiceEvent.MarkedInvalid));
+
+            if (redirect)
+            {
+                return RedirectToAction(nameof(ViewPaymentRequest), new
+                {
+                    Id = id,
+                    StatusMessage = "Payment cancelled"
+                });
+            }
+
+            return Ok("Payment cancelled");
+        }
+        
         private string GetUserId()
         {
             return _UserManager.GetUserId(User);

BTCPayServer/Controllers/ServerController.Storage.cs

@@ -0,0 +1,289 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Models;
+using BTCPayServer.Models.ServerViewModels;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.AmazonS3Storage;
+using BTCPayServer.Storage.Services.Providers.AmazonS3Storage.Configuration;
+using BTCPayServer.Storage.Services.Providers.AzureBlobStorage;
+using BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage.Configuration;
+using BTCPayServer.Storage.Services.Providers.GoogleCloudStorage;
+using BTCPayServer.Storage.Services.Providers.GoogleCloudStorage.Configuration;
+using BTCPayServer.Storage.Services.Providers.Models;
+using BTCPayServer.Storage.ViewModels;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class ServerController
+    {
+        [HttpGet("server/files/{fileId?}")]
+        public async Task<IActionResult> Files(string fileId = null, string statusMessage = null)
+        {
+            TempData["StatusMessage"] = statusMessage;
+            var fileUrl = string.IsNullOrEmpty(fileId) ? null : await _FileService.GetFileUrl(fileId);
+
+            return View(new ViewFilesViewModel()
+            {
+                Files = await _StoredFileRepository.GetFiles(),
+                SelectedFileId = string.IsNullOrEmpty(fileUrl) ? null : fileId,
+                DirectFileUrl = fileUrl,
+                StorageConfigured = (await _SettingsRepository.GetSettingAsync<StorageSettings>()) != null
+            });
+        }
+
+        [HttpGet("server/files/{fileId}/delete")]
+        public async Task<IActionResult> DeleteFile(string fileId)
+        {
+            try
+            {
+                await _FileService.RemoveFile(fileId, null);
+                return RedirectToAction(nameof(Files), new
+                {
+                    fileId = "",
+                    statusMessage = "File removed"
+                });
+            }
+            catch (Exception e)
+            {
+                return RedirectToAction(nameof(Files), new
+                {
+                    statusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = e.Message
+                    }
+                });
+            }
+        }
+
+        [HttpGet("server/files/{fileId}/tmp")]
+        public async Task<IActionResult> CreateTemporaryFileUrl(string fileId)
+        {
+            var file = await _StoredFileRepository.GetFile(fileId);
+
+            if (file == null)
+            {
+                return NotFound();
+            }
+
+            return View(new CreateTemporaryFileUrlViewModel());
+        }
+
+        [HttpPost("server/files/{fileId}/tmp")]
+        public async Task<IActionResult> CreateTemporaryFileUrl(string fileId,
+            CreateTemporaryFileUrlViewModel viewModel)
+        {
+            if (viewModel.TimeAmount <= 0)
+            {
+                ModelState.AddModelError(nameof(viewModel.TimeAmount), "Time must be at least 1");
+            }
+            
+            if (!ModelState.IsValid)
+            {
+                return View(viewModel);
+            }
+
+            var file = await _StoredFileRepository.GetFile(fileId);
+
+            if (file == null)
+            {
+                return NotFound();
+            }
+
+            var expiry = DateTimeOffset.Now;
+            switch (viewModel.TimeType)
+            {
+                case CreateTemporaryFileUrlViewModel.TmpFileTimeType.Seconds:
+                    expiry =expiry.AddSeconds(viewModel.TimeAmount);
+                    break;
+                case CreateTemporaryFileUrlViewModel.TmpFileTimeType.Minutes:
+                    expiry = expiry.AddMinutes(viewModel.TimeAmount);
+                    break;
+                case CreateTemporaryFileUrlViewModel.TmpFileTimeType.Hours:
+                    expiry = expiry.AddHours(viewModel.TimeAmount);
+                    break;
+                case CreateTemporaryFileUrlViewModel.TmpFileTimeType.Days:
+                    expiry = expiry.AddDays(viewModel.TimeAmount);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            var url = await _FileService.GetTemporaryFileUrl(fileId, expiry, viewModel.IsDownload);
+
+            return RedirectToAction(nameof(Files), new
+            {
+                StatusMessage = new StatusMessageModel()
+                {
+                    Html =
+                        $"Generated Temporary Url for file {file.FileName} which expires at {expiry:G}. <a href='{url}' target='_blank'>{url}</a>"
+                }.ToString(),
+                fileId,
+            });
+
+        }
+
+        public class CreateTemporaryFileUrlViewModel
+        {
+            public enum TmpFileTimeType
+            {
+                Seconds,
+                Minutes,
+                Hours,
+                Days
+            }
+            public int TimeAmount { get; set; }
+            public TmpFileTimeType TimeType { get; set; }
+            public bool IsDownload { get; set; }
+        }
+
+
+        [HttpPost("server/files/upload")]
+        public async Task<IActionResult> CreateFile(IFormFile file)
+        {
+            var newFile = await _FileService.AddFile(file, GetUserId());
+            return RedirectToAction(nameof(Files), new
+            {
+                statusMessage = "File added!",
+                fileId = newFile.Id
+            });
+        }
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(ControllerContext.HttpContext.User);
+        }
+
+        [HttpGet("server/storage")]
+        public async Task<IActionResult> Storage(bool forceChoice = false, string statusMessage = null)
+        {
+            TempData["StatusMessage"] = statusMessage;
+            var savedSettings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
+            if (forceChoice || savedSettings == null)
+            {
+                return View(new ChooseStorageViewModel()
+                {
+                    ShowChangeWarning = savedSettings != null,
+                    Provider = savedSettings?.Provider ?? BTCPayServer.Storage.Models.StorageProvider.FileSystem
+                });
+            }
+
+            return RedirectToAction(nameof(StorageProvider), new
+            {
+                provider = savedSettings.Provider
+            });
+        }
+
+        [HttpPost("server/storage")]
+        public IActionResult Storage(StorageSettings viewModel)
+        {
+            return RedirectToAction("StorageProvider", "Server", new
+            {
+                provider = viewModel.Provider.ToString()
+            });
+        }
+
+        [HttpGet("server/storage/{provider}")]
+        public async Task<IActionResult> StorageProvider(string provider)
+        {
+            if (!Enum.TryParse(typeof(StorageProvider), provider, out var storageProvider))
+            {
+                return RedirectToAction(nameof(Storage), new
+                {
+                    StatusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = $"{provider} provider is not supported"
+                    }.ToString()
+                });
+            }
+
+            var data = (await _SettingsRepository.GetSettingAsync<StorageSettings>()) ?? new StorageSettings();
+
+            var storageProviderService =
+                _StorageProviderServices.SingleOrDefault(service => service.StorageProvider().Equals(storageProvider));
+
+            switch (storageProviderService)
+            {
+                case null:
+                    return RedirectToAction(nameof(Storage), new
+                    {
+                        StatusMessage = new StatusMessageModel()
+                        {
+                            Severity = StatusMessageModel.StatusSeverity.Error,
+                            Message = $"{storageProvider} is not supported"
+                        }.ToString()
+                    });
+                case AzureBlobStorageFileProviderService fileProviderService:
+                    return View(nameof(EditAzureBlobStorageStorageProvider),
+                        fileProviderService.GetProviderConfiguration(data));
+
+                case AmazonS3FileProviderService fileProviderService:
+                    return View(nameof(EditAmazonS3StorageProvider),
+                        fileProviderService.GetProviderConfiguration(data));
+
+                case GoogleCloudStorageFileProviderService fileProviderService:
+                    return View(nameof(EditGoogleCloudStorageStorageProvider),
+                        fileProviderService.GetProviderConfiguration(data));
+
+                case FileSystemFileProviderService fileProviderService:
+                    return View(nameof(EditFileSystemStorageProvider),
+                        fileProviderService.GetProviderConfiguration(data));
+            }
+
+            return NotFound();
+        }
+
+
+        [HttpPost("server/storage/AzureBlobStorage")]
+        public async Task<IActionResult> EditAzureBlobStorageStorageProvider(AzureBlobStorageConfiguration viewModel)
+        {
+            return await SaveStorageProvider(viewModel, BTCPayServer.Storage.Models.StorageProvider.AzureBlobStorage);
+        }
+
+        [HttpPost("server/storage/AmazonS3")]
+        public async Task<IActionResult> EditAmazonS3StorageProvider(AmazonS3StorageConfiguration viewModel)
+        {
+            return await SaveStorageProvider(viewModel, BTCPayServer.Storage.Models.StorageProvider.AmazonS3);
+        }
+
+        [HttpPost("server/storage/GoogleCloudStorage")]
+        public async Task<IActionResult> EditGoogleCloudStorageStorageProvider(
+            GoogleCloudStorageConfiguration viewModel)
+        {
+            return await SaveStorageProvider(viewModel, BTCPayServer.Storage.Models.StorageProvider.GoogleCloudStorage);
+        }
+
+        [HttpPost("server/storage/FileSystem")]
+        public async Task<IActionResult> EditFileSystemStorageProvider(FileSystemStorageConfiguration viewModel)
+        {
+            return await SaveStorageProvider(viewModel, BTCPayServer.Storage.Models.StorageProvider.FileSystem);
+        }
+
+        private async Task<IActionResult> SaveStorageProvider(IBaseStorageConfiguration viewModel,
+            StorageProvider storageProvider)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(viewModel);
+            }
+
+            var data = (await _SettingsRepository.GetSettingAsync<StorageSettings>()) ?? new StorageSettings();
+            data.Provider = storageProvider;
+            data.Configuration = JObject.FromObject(viewModel);
+            await _SettingsRepository.UpdateSetting(data);
+            TempData["StatusMessage"] = new StatusMessageModel()
+            {
+                Severity = StatusMessageModel.StatusSeverity.Success,
+                Message = "Storage settings updated successfully"
+            }.ToString();
+            return View(viewModel);
+        }
+    }
+}

BTCPayServer/Controllers/ServerController.cs

@@ -27,6 +27,9 @@ using Renci.SshNet;
 using BTCPayServer.Logging;
 using BTCPayServer.Lightning;
 using System.Runtime.CompilerServices;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services;
+using BTCPayServer.Storage.Services.Providers;
 using BTCPayServer.Services.Apps;
 using Microsoft.AspNetCore.Mvc.Rendering;
 using BTCPayServer.Data;
@@ -34,7 +37,7 @@ using BTCPayServer.Data;
 namespace BTCPayServer.Controllers
 {
     [Authorize(Policy = BTCPayServer.Security.Policies.CanModifyServerSettings.Key)]
-    public class ServerController : Controller
+    public partial class ServerController : Controller
     {
         private UserManager<ApplicationUser> _UserManager;
         SettingsRepository _SettingsRepository;
@@ -45,8 +48,14 @@ namespace BTCPayServer.Controllers
         private readonly TorServices _torServices;
         BTCPayServerOptions _Options;
         ApplicationDbContextFactory _ContextFactory;
+        private readonly StoredFileRepository _StoredFileRepository;
+        private readonly FileService _FileService;
+        private readonly IEnumerable<IStorageProviderService> _StorageProviderServices;
 
         public ServerController(UserManager<ApplicationUser> userManager,
+            StoredFileRepository storedFileRepository,
+            FileService fileService,
+            IEnumerable<IStorageProviderService> storageProviderServices,
             BTCPayServerOptions options,
             RateFetcher rateProviderFactory,
             SettingsRepository settingsRepository,
@@ -58,6 +67,9 @@ namespace BTCPayServer.Controllers
             ApplicationDbContextFactory contextFactory)
         {
             _Options = options;
+            _StoredFileRepository = storedFileRepository;
+            _FileService = fileService;
+            _StorageProviderServices = storageProviderServices;
             _UserManager = userManager;
             _SettingsRepository = settingsRepository;
             _dashBoard = dashBoard;
@@ -490,10 +502,10 @@ namespace BTCPayServer.Controllers
         }
 
         [Route("server/services")]
-        public IActionResult Services()
+        public async Task<IActionResult> Services()
         {
             var result = new ServicesViewModel();
-            result.ExternalServices = _Options.ExternalServices;
+            result.ExternalServices = _Options.ExternalServices.ToList();
             foreach (var externalService in _Options.OtherExternalServices)
             {
                 result.OtherExternalServices.Add(new ServicesViewModel.OtherExternalService()
@@ -520,6 +532,10 @@ namespace BTCPayServer.Controllers
                         Link = $"http://{torService.OnionHost}"
                     });
                 }
+                else if (TryParseAsExternalService(torService, out var externalService))
+                {
+                    result.ExternalServices.Add(externalService);
+                }
                 else
                 {
                     result.TorOtherServices.Add(new ServicesViewModel.OtherExternalService()
@@ -529,9 +545,42 @@ namespace BTCPayServer.Controllers
                     });
                 }
             }
+
+            var storageSettings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
+            result.ExternalStorageServices.Add(new ServicesViewModel.OtherExternalService()
+            {
+                Name = storageSettings == null? "Not set": storageSettings.Provider.ToString(),
+                Link = Url.Action("Storage")
+            });
             return View(result);
         }
 
+        private static bool TryParseAsExternalService(TorService torService, out ExternalService externalService)
+        {
+            externalService = null;
+            if (torService.ServiceType == TorServiceType.P2P)
+            {
+                externalService = new ExternalService()
+                {
+                    CryptoCode = torService.Network.CryptoCode,
+                    DisplayName = "Full node P2P",
+                    Type = ExternalServiceTypes.P2P,
+                    ConnectionString = new ExternalConnectionString(new Uri($"bitcoin-p2p://{torService.OnionHost}:{torService.VirtualPort}", UriKind.Absolute)),
+                    ServiceName = torService.Name,
+                };
+            }
+            return externalService != null;
+        }
+
+        private ExternalService GetService(string serviceName, string cryptoCode)
+        {
+            var result = _Options.ExternalServices.GetService(serviceName, cryptoCode);
+            if (result != null)
+                return result;
+            _torServices.Services.FirstOrDefault(s => TryParseAsExternalService(s, out result));
+            return result;
+        }
+
         [Route("server/services/{serviceName}/{cryptoCode}")]
         public async Task<IActionResult> Service(string serviceName, string cryptoCode, bool showQR = false, uint? nonce = null)
         {
@@ -540,12 +589,21 @@ namespace BTCPayServer.Controllers
                 StatusMessage = $"Error: {cryptoCode} is not fully synched";
                 return RedirectToAction(nameof(Services));
             }
-            var service = _Options.ExternalServices.GetService(serviceName, cryptoCode);
+            var service = GetService(serviceName, cryptoCode);
             if (service == null)
                 return NotFound();
 
             try
             {
+                if (service.Type == ExternalServiceTypes.P2P)
+                {
+                    return View("P2PService", new LightningWalletServices()
+                    {
+                        ShowQR = showQR,
+                        WalletName = service.ServiceName,
+                        ServiceLink = service.ConnectionString.Server.AbsoluteUri.WithoutEndingSlash()
+                    });
+                }
                 var connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type);
                 switch (service.Type)
                 {
@@ -655,7 +713,7 @@ namespace BTCPayServer.Controllers
                 StatusMessage = $"Error: {cryptoCode} is not fully synched";
                 return RedirectToAction(nameof(Services));
             }
-            var service = _Options.ExternalServices.GetService(serviceName, cryptoCode);
+            var service = GetService(serviceName, cryptoCode);
             if (service == null)
                 return NotFound();
 

BTCPayServer/Controllers/StorageController.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using BTCPayServer.Storage.Services;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Storage
+{
+    [Route("Storage")]
+    public class StorageController
+    {
+        private readonly FileService _FileService;
+
+        public StorageController(FileService fileService)
+        {
+            _FileService = fileService;
+        }
+
+        [HttpGet("{fileId}")]
+        public async Task<IActionResult> GetFile(string fileId)
+        {
+            var url = await _FileService.GetFileUrl(fileId);
+            return new RedirectResult(url);
+        }
+    }
+}

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, bool advancedMode = false)
+            WalletId walletId, string defaultDestination = null, string defaultAmount = null)
         {
             if (walletId?.StoreId == null)
                 return NotFound();
@@ -175,7 +175,7 @@ namespace BTCPayServer.Controllers
             model.CurrentBalance = (await balance).ToDecimal(MoneyUnit.BTC);
             model.RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi;
             model.FeeSatoshiPerByte = model.RecommendedSatoshiPerByte;
-
+            model.SupportRBF = network.SupportRBF;
             using (CancellationTokenSource cts = new CancellationTokenSource())
             {
                 try
@@ -195,7 +195,6 @@ namespace BTCPayServer.Controllers
                 }
                 catch (Exception ex) { model.RateError = ex.Message; }
             }
-            model.AdvancedMode = advancedMode;
             return View(model);
         }
 
@@ -203,7 +202,7 @@ namespace BTCPayServer.Controllers
         [Route("{walletId}/send")]
         public async Task<IActionResult> WalletSend(
             [ModelBinder(typeof(WalletIdModelBinder))]
-            WalletId walletId, WalletSendModel vm, string command = null)
+            WalletId walletId, WalletSendModel vm, string command = null, CancellationToken cancellation = default)
         {
             if (walletId?.StoreId == null)
                 return NotFound();
@@ -213,14 +212,7 @@ 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);
-            }
-
+            vm.SupportRBF = network.SupportRBF;
             var destination = ParseDestination(vm.Destination, network.NBitcoinNetwork);
             if (destination == null)
                 ModelState.AddModelError(nameof(vm.Destination), "Invalid address");
@@ -235,14 +227,63 @@ namespace BTCPayServer.Controllers
             if (!ModelState.IsValid)
                 return View(vm);
 
-            return RedirectToAction(nameof(WalletSendLedger), new WalletSendLedgerModel()
+            var sendModel = new WalletSendLedgerModel()
             {
                 Destination = vm.Destination,
                 Amount = vm.Amount.Value,
                 SubstractFees = vm.SubstractFees,
                 FeeSatoshiPerByte = vm.FeeSatoshiPerByte,
-                NoChange = vm.NoChange
-            });
+                NoChange = vm.NoChange,
+                DisableRBF = vm.DisableRBF
+            };
+            if (command == "ledger")
+            {
+                return RedirectToAction(nameof(WalletSendLedger), sendModel);
+            }
+            else
+            {
+                var storeData = (await Repository.FindStore(walletId.StoreId, GetUserId()));
+                var derivationScheme = GetPaymentMethod(walletId, storeData).DerivationStrategyBase;
+                var psbt = await CreatePSBT(network, derivationScheme, sendModel, cancellation);
+                return File(psbt.PSBT.ToBytes(), "application/octet-stream", $"Send-{vm.Amount.Value}-{network.CryptoCode}-to-{destination[0].ToString()}.psbt");
+            }
+        }
+
+        private async Task<CreatePSBTResponse> CreatePSBT(BTCPayNetwork network, DerivationStrategyBase derivationScheme, WalletSendLedgerModel sendModel, CancellationToken cancellationToken)
+        {
+            var nbx = ExplorerClientProvider.GetExplorerClient(network);
+            CreatePSBTRequest psbtRequest = new CreatePSBTRequest();
+            CreatePSBTDestination psbtDestination = new CreatePSBTDestination();
+            psbtRequest.Destinations.Add(psbtDestination);
+            if (network.SupportRBF)
+            {
+                psbtRequest.RBF = !sendModel.DisableRBF;
+            }
+            psbtDestination.Destination = BitcoinAddress.Create(sendModel.Destination, network.NBitcoinNetwork);
+            psbtDestination.Amount = Money.Coins(sendModel.Amount);
+            psbtRequest.FeePreference = new FeePreference();
+            psbtRequest.FeePreference.ExplicitFeeRate = new FeeRate(Money.Satoshis(sendModel.FeeSatoshiPerByte), 1);
+            if (sendModel.NoChange)
+            {
+                psbtRequest.ExplicitChangeAddress = psbtDestination.Destination;
+            }
+            psbtDestination.SubstractFees = sendModel.SubstractFees;
+
+            var psbt = (await nbx.CreatePSBTAsync(derivationScheme, psbtRequest, cancellationToken));
+            if (psbt == null)
+                throw new NotSupportedException("You need to update your version of NBXplorer");
+
+            if (network.MinFee != null)
+            {
+                psbt.PSBT.TryGetFee(out var fee);
+                if (fee < network.MinFee)
+                {
+                    psbtRequest.FeePreference = new FeePreference() { ExplicitFee = network.MinFee };
+                    psbt = (await nbx.CreatePSBTAsync(derivationScheme, psbtRequest, cancellationToken));
+                }
+            }
+
+            return psbt;
         }
 
         [HttpGet]
@@ -291,9 +332,6 @@ namespace BTCPayServer.Controllers
 
             var vm = new RescanWalletModel();
             vm.IsFullySync = _dashboard.IsFullySynched(walletId.CryptoCode, out var unused);
-            // We need to ensure it is segwit, 
-            // because hardware wallet support need the parent transactions to sign, which NBXplorer don't have. (Nor does a pruned node)
-            vm.IsSegwit = paymentMethod.DerivationStrategyBase.IsSegwit();
             vm.IsServerAdmin = User.Claims.Any(c => c.Type == Policies.CanModifyServerSettings.Key && c.Value == "true");
             vm.IsSupportedByCurrency = _dashboard.Get(walletId.CryptoCode)?.Status?.BitcoinStatus?.Capabilities?.CanScanTxoutSet == true;
             var explorer = ExplorerClientProvider.GetExplorerClient(walletId.CryptoCode);
@@ -414,7 +452,7 @@ namespace BTCPayServer.Controllers
             int account = 0,
             // sendtoaddress
             bool noChange = false,
-            string destination = null, string amount = null, string feeRate = null, string substractFees = null
+            string destination = null, string amount = null, string feeRate = null, bool substractFees = false, bool disableRBF = false
             )
         {
             if (!HttpContext.WebSockets.IsWebSocketRequest)
@@ -431,6 +469,7 @@ namespace BTCPayServer.Controllers
             {
                 normalOperationTimeout.CancelAfter(TimeSpan.FromMinutes(30));
                 var hw = new HardwareWalletService(webSocket);
+                var model = new WalletSendLedgerModel();
                 object result = null;
                 try
                 {
@@ -442,51 +481,42 @@ namespace BTCPayServer.Controllers
                             throw new FormatException("Invalid value for crypto code");
                     }
 
-                    BitcoinAddress destinationAddress = null;
                     if (destination != null)
                     {
                         try
                         {
-                            destinationAddress = BitcoinAddress.Create(destination.Trim(), network.NBitcoinNetwork);
+                            BitcoinAddress.Create(destination.Trim(), network.NBitcoinNetwork);
+                            model.Destination = destination.Trim();
                         }
                         catch { }
-                        if (destinationAddress == null)
-                            throw new FormatException("Invalid value for destination");
                     }
 
-                    FeeRate feeRateValue = null;
+                    
                     if (feeRate != null)
                     {
                         try
                         {
-                            feeRateValue = new FeeRate(Money.Satoshis(int.Parse(feeRate, CultureInfo.InvariantCulture)), 1);
+                            model.FeeSatoshiPerByte = int.Parse(feeRate, CultureInfo.InvariantCulture);
                         }
                         catch { }
-                        if (feeRateValue == null || feeRateValue.FeePerK <= Money.Zero)
+                        if (model.FeeSatoshiPerByte <= 0)
                             throw new FormatException("Invalid value for fee rate");
                     }
 
-                    Money amountBTC = null;
                     if (amount != null)
                     {
                         try
                         {
-                            amountBTC = Money.Parse(amount);
+                            model.Amount = Money.Parse(amount).ToDecimal(MoneyUnit.BTC);
                         }
                         catch { }
-                        if (amountBTC == null || amountBTC <= Money.Zero)
+                        if (model.Amount <= 0m)
                             throw new FormatException("Invalid value for amount");
                     }
 
-                    bool subsctractFeesValue = false;
-                    if (substractFees != null)
-                    {
-                        try
-                        {
-                            subsctractFeesValue = bool.Parse(substractFees);
-                        }
-                        catch { throw new FormatException("Invalid value for subtract fees"); }
-                    }
+                    model.SubstractFees = substractFees;
+                    model.NoChange = noChange;
+                    model.DisableRBF = disableRBF;
                     if (command == "test")
                     {
                         result = await hw.Test(normalOperationTimeout.Token);
@@ -495,19 +525,10 @@ namespace BTCPayServer.Controllers
                     {
                         if (!_dashboard.IsFullySynched(network.CryptoCode, out var summary))
                             throw new Exception($"{network.CryptoCode}: not started or fully synched");
+
+                        var psbt = await CreatePSBT(network, derivationScheme, model, normalOperationTimeout.Token);
+
                         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 changeAddress = await change;
-
                         var storeBlob = storeData.GetStoreBlob();
                         var paymentId = new Payments.PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike);
                         var foundKeyPath = storeBlob.GetWalletKeyPathRoot(paymentId);
@@ -523,97 +544,41 @@ namespace BTCPayServer.Controllers
                             storeData.SetStoreBlob(storeBlob);
                             await Repository.UpdateStore(storeData);
                         }
-retry:
-                        var send = new[] { (
-                        destination: destinationAddress as IDestination,
-                        amount: amountBTC,
-                        substractFees: subsctractFeesValue) };
 
-                        foreach (var element in send)
+                        // NBX only know the path relative to the account xpub.
+                        // Here we rebase the hd_keys in the PSBT to have a keypath relative to the root HD so the wallet can sign
+                        // Note that the fingerprint of the hd keys are now 0, which is wrong
+                        // However, hardware wallets does not give a damn, and sometimes does not even allow us to get this fingerprint anyway.
+                        foreach (var o in psbt.PSBT.Inputs.OfType<PSBTCoin>().Concat(psbt.PSBT.Outputs))
                         {
-                            if (element.destination == null)
-                                throw new ArgumentNullException(nameof(element.destination));
-                            if (element.amount == null)
-                                throw new ArgumentNullException(nameof(element.amount));
-                            if (element.amount <= Money.Zero)
-                                throw new ArgumentOutOfRangeException(nameof(element.amount), "The amount should be above zero");
-                        }
-
-                        TransactionBuilder builder = network.NBitcoinNetwork.CreateTransactionBuilder();
-                        builder.StandardTransactionPolicy.MinRelayTxFee = summary.Status.BitcoinStatus.MinRelayTxFee;
-                        builder.AddCoins(availableCoins);
-
-                        foreach (var element in send)
-                        {
-                            builder.Send(element.destination, element.amount);
-                            if (element.substractFees)
-                                builder.SubtractFees();
-                        }
-
-                        builder.SetChange(changeAddress.Item1);
-
-                        if (network.MinFee == null)
-                        {
-                            builder.SendEstimatedFees(feeRateValue);
-                        }
-                        else
-                        {
-                            var estimatedFee = builder.EstimateFees(feeRateValue);
-                            if (network.MinFee > estimatedFee)
-                                builder.SendFees(network.MinFee);
-                            else
-                                builder.SendEstimatedFees(feeRateValue);
-                        }
-                        var unsigned = builder.BuildTransaction(false);
-
-                        var hasChange = unsigned.Outputs.Any(o => o.ScriptPubKey == changeAddress.Item1.ScriptPubKey);
-                        if (noChange && hasChange)
-                        {
-                            availableCoins = builder.FindSpentCoins(unsigned).Cast<Coin>().ToList();
-                            amountBTC = builder.FindSpentCoins(unsigned).Select(c => c.TxOut.Value).Sum();
-                            subsctractFeesValue = true;
-                            goto retry;
-                        }
-
-                        var usedCoins = builder.FindSpentCoins(unsigned);
-
-                        Dictionary<uint256, Transaction> parentTransactions = new Dictionary<uint256, Transaction>();
-
-                        if (!strategy.Segwit)
-                        {
-                            var parentHashes = usedCoins.Select(c => c.Outpoint.Hash).ToHashSet();
-                            var explorer = ExplorerClientProvider.GetExplorerClient(network);
-                            var getTransactionAsyncs = parentHashes.Select(h => (Op: explorer.GetTransactionAsync(h), Hash: h)).ToList();
-                            foreach (var getTransactionAsync in getTransactionAsyncs)
+                            foreach (var keypath in o.HDKeyPaths.ToList())
                             {
-                                var tx = (await getTransactionAsync.Op);
-                                if (tx == null)
-                                    throw new Exception($"Parent transaction {getTransactionAsync.Hash} not found");
-                                parentTransactions.Add(tx.Transaction.GetHash(), tx.Transaction);
+                                var newKeyPath = foundKeyPath.Derive(keypath.Value.Item2);
+                                o.HDKeyPaths.Remove(keypath.Key);
+                                o.HDKeyPaths.Add(keypath.Key, Tuple.Create(default(HDFingerprint), newKeyPath));
                             }
                         }
 
-
                         signTimeout.CancelAfter(TimeSpan.FromMinutes(5));
-                        var transaction = await hw.SignTransactionAsync(usedCoins.Select(c => new SignatureRequest
+                        psbt.PSBT = await hw.SignTransactionAsync(psbt.PSBT, psbt.ChangeAddress?.ScriptPubKey, signTimeout.Token);
+                        if(!psbt.PSBT.TryFinalize(out var errors))
                         {
-                            InputTransaction = parentTransactions.TryGet(c.Outpoint.Hash),
-                            InputCoin = c,
-                            KeyPath = foundKeyPath.Derive(keypaths[c.TxOut.ScriptPubKey]),
-                            PubKey = strategy.Root.Derive(keypaths[c.TxOut.ScriptPubKey]).PubKey
-                        }).ToArray(), unsigned, hasChange ? foundKeyPath.Derive(changeAddress.Item2) : null, signTimeout.Token);
+                            throw new Exception($"Error while finalizing the transaction ({new PSBTException(errors).ToString()})");
+                        }
+                        var transaction = psbt.PSBT.ExtractTransaction();
                         try
                         {
-                            var broadcastResult = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { transaction });
-                            if (!broadcastResult[0].Success)
+                            var broadcastResult = await ExplorerClientProvider.GetExplorerClient(network).BroadcastAsync(transaction);
+                            if (!broadcastResult.Success)
                             {
-                                throw new Exception($"RPC Error while broadcasting: {broadcastResult[0].RPCCode} {broadcastResult[0].RPCCodeMessage} {broadcastResult[0].RPCMessage}");
+                                throw new Exception($"RPC Error while broadcasting: {broadcastResult.RPCCode} {broadcastResult.RPCCodeMessage} {broadcastResult.RPCMessage}");
                             }
                         }
                         catch (Exception ex)
                         {
                             throw new Exception("Error while broadcasting: " + ex.Message);
                         }
+                        var wallet = _walletProvider.GetWallet(network);
                         wallet.InvalidateCache(derivationScheme);
                         result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
                     }

BTCPayServer/Data/ApplicationDbContext.cs

@@ -1,12 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Linq;
 using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Models;
 using BTCPayServer.Services.PaymentRequests;
-using Microsoft.EntityFrameworkCore.Infrastructure.Internal;
+using BTCPayServer.Services.U2F.Models;
+using BTCPayServer.Storage.Models;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
 namespace BTCPayServer.Data
@@ -93,10 +91,18 @@ namespace BTCPayServer.Data
         }
 
         public DbSet<APIKeyData> ApiKeys
+        {
+            get; set;
+        } 
+        
+        public DbSet<StoredFile> Files
         {
             get; set;
         }
+       
 
+        public DbSet<U2FDevice> U2FDevices { get; set; }   
+        
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             var isConfigured = optionsBuilder.Options.Extensions.OfType<RelationalOptionsExtension>().Any();
@@ -221,4 +227,5 @@ namespace BTCPayServer.Data
                 .HasIndex(o => o.Status);
         }
     }
+
 }

BTCPayServer/Extensions.cs

@@ -132,6 +132,12 @@ namespace BTCPayServer
                 return str;
             return $"/{str}";
         }
+        public static string WithoutEndingSlash(this string str)
+        {
+            if (str.EndsWith("/", StringComparison.InvariantCulture))
+                return str.Substring(0, str.Length - 1);
+            return str;
+        }
 
         public static void SetHeaderOnStarting(this HttpResponse resp, string name, string value)
         {

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -49,7 +49,7 @@ namespace BTCPayServer.HostedServices
         }
         public NBXplorerSummary Get(string cryptoCode)
         {
-            _Summaries.TryGetValue(cryptoCode, out var summary);
+            _Summaries.TryGetValue(cryptoCode.ToUpperInvariant(), out var summary);
             return summary;
         }
         public IEnumerable<NBXplorerSummary> GetAll()

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -47,6 +47,7 @@ using NBXplorer.DerivationStrategy;
 using NicolasDorier.RateLimits;
 using Npgsql;
 using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.U2F;
 using BundlerMinifier.TagHelpers;
 
 namespace BTCPayServer.Hosting
@@ -80,6 +81,7 @@ namespace BTCPayServer.Hosting
             services.TryAddSingleton<TokenRepository>();
             services.TryAddSingleton<EventAggregator>();
             services.TryAddSingleton<PaymentRequestService>();
+            services.TryAddSingleton<U2FService>();
             services.TryAddSingleton<CoinAverageSettings>();
             services.TryAddSingleton<ApplicationDbContextFactory>(o => 
             {

BTCPayServer/Hosting/ResourceBundleProvider.cs

@@ -28,8 +28,8 @@ namespace BTCPayServer.Hosting
                         return JArray.Parse(content).OfType<JObject>()
                                .Select(jobj => new Bundle()
                                {
-                                   Name = jobj.Property("name")?.Value.Value<string>() ?? jobj.Property("outputFileName").Value.Value<string>(),
-                                   OutputFileUrl = Path.Combine(hosting.ContentRootPath, jobj.Property("outputFileName").Value.Value<string>())
+                                   Name = jobj.Property("name", StringComparison.OrdinalIgnoreCase)?.Value.Value<string>() ?? jobj.Property("outputFileName", StringComparison.OrdinalIgnoreCase).Value.Value<string>(),
+                                   OutputFileUrl = Path.Combine(hosting.ContentRootPath, jobj.Property("outputFileName", StringComparison.OrdinalIgnoreCase).Value.Value<string>())
                                }).ToDictionary(o => o.Name, o => o);
                     }
                 }, true);

BTCPayServer/Hosting/Startup.cs

@@ -36,6 +36,10 @@ using System.Net;
 using BTCPayServer.PaymentRequest;
 using BTCPayServer.Security;
 using BTCPayServer.Services.Apps;
+using BTCPayServer.Storage;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.FileProviders;
 
 namespace BTCPayServer.Hosting
 {
@@ -64,6 +68,7 @@ namespace BTCPayServer.Hosting
                 .AddDefaultTokenProviders();
             services.AddSignalR();
             services.AddBTCPayServer();
+            services.AddProviderStorage();
             services.AddSession();
             services.AddMvc(o =>
             {
@@ -169,6 +174,7 @@ namespace BTCPayServer.Hosting
             app.UseCors();
             app.UsePayServer();
             app.UseStaticFiles();
+            app.UseProviderStorage(options);
             app.UseAuthentication();
             app.UseSession();
             app.UseSignalR(route =>

BTCPayServer/Migrations/20190324141717_AddFiles.Designer.cs

@@ -0,0 +1,635 @@
+// <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("20190324141717_AddFiles")]
+    partial class AddFiles
+    {
+        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("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<int>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PaymentRequests");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Storage.Models.StoredFile", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("FileName");
+
+                    b.Property<string>("StorageFileName");
+
+                    b.Property<DateTime>("Timestamp");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("Files");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("APIKeys")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Apps")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Invoices")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PairedSINs")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("PendingInvoices")
+                        .HasForeignKey("Id")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PaymentRequests")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Storage.Models.StoredFile", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("StoredFiles")
+                        .HasForeignKey("ApplicationUserId");
+                });
+
+            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/20190324141717_AddFiles.cs

@@ -0,0 +1,43 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class AddFiles : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Files",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    FileName = table.Column<string>(nullable: true),
+                    StorageFileName = table.Column<string>(nullable: true),
+                    Timestamp = table.Column<DateTime>(nullable: false),
+                    ApplicationUserId = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Files", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Files_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Files_ApplicationUserId",
+                table: "Files",
+                column: "ApplicationUserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Files");
+        }
+    }
+}

BTCPayServer/Migrations/20190425081749_AddU2fDevices.Designer.cs

@@ -0,0 +1,667 @@
+// <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("20190425081749_AddU2fDevices")]
+    partial class AddU2fDevices
+    {
+        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>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<int>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PaymentRequests");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.U2F.Models.U2FDevice", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<byte[]>("AttestationCert")
+                        .IsRequired();
+
+                    b.Property<int>("Counter");
+
+                    b.Property<byte[]>("KeyHandle")
+                        .IsRequired();
+
+                    b.Property<string>("Name");
+
+                    b.Property<byte[]>("PublicKey")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("U2FDevices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Storage.Models.StoredFile", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("FileName");
+
+                    b.Property<string>("StorageFileName");
+
+                    b.Property<DateTime>("Timestamp");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("Files");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("APIKeys")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Apps")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Invoices")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PairedSINs")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("PendingInvoices")
+                        .HasForeignKey("Id")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.PaymentRequests.PaymentRequestData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("PaymentRequests")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Services.U2F.Models.U2FDevice", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("U2FDevices")
+                        .HasForeignKey("ApplicationUserId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Storage.Models.StoredFile", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("StoredFiles")
+                        .HasForeignKey("ApplicationUserId");
+                });
+
+            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/20190425081749_AddU2fDevices.cs

@@ -0,0 +1,60 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class AddU2fDevices : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            if (this.SupportDropColumn(migrationBuilder.ActiveProvider))
+            {
+                migrationBuilder.DropColumn(
+                    name: "Facade",
+                    table: "PairedSINData");
+            }
+
+            migrationBuilder.CreateTable(
+                name: "U2FDevices",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    Name = table.Column<string>(nullable: true),
+                    KeyHandle = table.Column<byte[]>(nullable: false),
+                    PublicKey = table.Column<byte[]>(nullable: false),
+                    AttestationCert = table.Column<byte[]>(nullable: false),
+                    Counter = table.Column<int>(nullable: false),
+                    ApplicationUserId = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_U2FDevices", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_U2FDevices_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_U2FDevices_ApplicationUserId",
+                table: "U2FDevices",
+                column: "ApplicationUserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "U2FDevices");
+            //if it did not support dropping it, then it is still here and re-adding it would throw
+            if (this.SupportDropColumn(migrationBuilder.ActiveProvider))
+            {
+                migrationBuilder.AddColumn<string>(
+                    name: "Facade",
+                    table: "PairedSINData",
+                    nullable: true);
+            }
+        }
+    }
+}

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -137,8 +137,6 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Id")
                         .ValueGeneratedOnAdd();
 
-                    b.Property<string>("Facade");
-
                     b.Property<string>("Label");
 
                     b.Property<DateTimeOffset>("PairingTime");
@@ -348,6 +346,53 @@ namespace BTCPayServer.Migrations
                     b.ToTable("PaymentRequests");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Services.U2F.Models.U2FDevice", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<byte[]>("AttestationCert")
+                        .IsRequired();
+
+                    b.Property<int>("Counter");
+
+                    b.Property<byte[]>("KeyHandle")
+                        .IsRequired();
+
+                    b.Property<string>("Name");
+
+                    b.Property<byte[]>("PublicKey")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("U2FDevices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Storage.Models.StoredFile", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("FileName");
+
+                    b.Property<string>("StorageFileName");
+
+                    b.Property<DateTime>("Timestamp");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("Files");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
                 {
                     b.Property<string>("Id")
@@ -556,6 +601,20 @@ namespace BTCPayServer.Migrations
                         .OnDelete(DeleteBehavior.Cascade);
                 });
 
+            modelBuilder.Entity("BTCPayServer.Services.U2F.Models.U2FDevice", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("U2FDevices")
+                        .HasForeignKey("ApplicationUserId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Storage.Models.StoredFile", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("StoredFiles")
+                        .HasForeignKey("ApplicationUserId");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")

BTCPayServer/Models/AccountViewModels/SecondaryLoginViewModel.cs

@@ -0,0 +1,10 @@
+using BTCPayServer.Services.U2F.Models;
+
+namespace BTCPayServer.Models.AccountViewModels
+{
+    public class SecondaryLoginViewModel
+    {
+        public LoginWith2faViewModel LoginWith2FaViewModel { get; set; }
+        public LoginWithU2FViewModel LoginWithU2FViewModel { get; set; }
+    }
+}

BTCPayServer/Models/AppViewModels/UpdateCrowdfundViewModel.cs

@@ -92,5 +92,7 @@ namespace BTCPayServer.Models.AppViewModels
         public string Sounds{ get; set; }
         [Display(Name = "Colors to rotate between with animation when a payment is made. First color is the default background. One color per line. Can be any valid css color value.")]
         public string AnimationColors{ get; set; }
+
+        public bool NotificationEmailWarning { get; set; }
     }
 }

BTCPayServer/Models/AppViewModels/UpdatePointOfSaleViewModel.cs

@@ -79,5 +79,7 @@ namespace BTCPayServer.Models.AppViewModels
                     Value = ""
                 }
             }, nameof(SelectListItem.Value), nameof(SelectListItem.Text), RedirectAutomatically);
+
+        public bool NotificationEmailWarning { get; set; }
     }
 }

BTCPayServer/Models/ApplicationUser.cs

@@ -4,6 +4,8 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity;
 using BTCPayServer.Data;
+using BTCPayServer.Services.U2F.Models;
+using BTCPayServer.Storage.Models;
 
 namespace BTCPayServer.Models
 {
@@ -20,5 +22,13 @@ namespace BTCPayServer.Models
         {
             get; set;
         }
+        
+        public List<StoredFile> StoredFiles
+        {
+            get;
+            set;
+        }
+        
+        public List<U2FDevice> U2FDevices { get; set; }
     }
 }

BTCPayServer/Models/GetTokensResponse.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Mvc;
+using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System;
@@ -35,7 +36,8 @@ namespace BTCPayServer.Models
             JObject jobj = new JObject();
             JArray jarray = new JArray();
             jobj.Add("data", jarray);
-            foreach (var token in _Tokens)
+            var token = _Tokens.FirstOrDefault();
+            if (token != null)
             {
                 JObject item = new JObject();
                 jarray.Add(item);

BTCPayServer/Models/InvoiceResponse.cs

@@ -121,6 +121,12 @@ namespace BTCPayServer.Models
         //"itemDesc":"Some description"
         [JsonProperty("itemDesc")]
         public string ItemDesc
+        {
+            get; set;
+        }       
+        
+        [JsonProperty("itemCode")]
+        public string ItemCode
         {
             get; set;
         }

BTCPayServer/Models/InvoicingModels/CreateInvoiceModel.cs

@@ -70,5 +70,16 @@ namespace BTCPayServer.Models.InvoicingModels
             get;
             set;
         }
+        
+        public List<string> SupportedTransactionCurrencies
+        {
+            get;
+            set;
+        }
+        public SelectList AvailablePaymentMethods
+        {
+            get;
+            set;
+        }
     }
 }

BTCPayServer/Models/InvoicingModels/InvoicesModel.cs

@@ -2,37 +2,20 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
 
 namespace BTCPayServer.Models.InvoicingModels
 {
     public class InvoicesModel
     {
-        public int Skip
-        {
-            get; set;
-        }
-        public int Count
-        {
-            get; set;
-        }
-        public int Total
-        {
-            get; set;
-        }
-        public string SearchTerm
-        {
-            get; set;
-        }
+        public int Skip { get; set; }
+        public int Count { get; set; }
+        public int Total { get; set; }
+        public string SearchTerm { get; set; }
+        public int? TimezoneOffset { get; set; }
 
-        public List<InvoiceModel> Invoices
-        {
-            get; set;
-        } = new List<InvoiceModel>();
-        public string StatusMessage
-        {
-            get;
-            set;
-        }
+        public List<InvoiceModel> Invoices { get; set; } = new List<InvoiceModel>();
+        public string StatusMessage { get; set; }
     }
 
     public class InvoiceModel
@@ -41,27 +24,18 @@ namespace BTCPayServer.Models.InvoicingModels
 
         public string OrderId { get; set; }
         public string RedirectUrl { get; set; }
-        public string InvoiceId
-        {
-            get; set;
-        }
+        public string InvoiceId { get; set; }
 
-        public string Status
-        {
-            get; set;
-        }
+        public InvoiceStatus Status { get; set; }
+        public string StatusString { get; set; }
         public bool CanMarkComplete { get; set; }
         public bool CanMarkInvalid { get; set; }
         public bool CanMarkStatus => CanMarkComplete || CanMarkInvalid;
         public bool ShowCheckout { get; set; }
         public string ExceptionStatus { get; set; }
-        public string AmountCurrency
-        {
-            get; set;
-        }
-        public string StatusMessage
-        {
-            get; set;
-        }
+        public string AmountCurrency { get; set; }
+        public string StatusMessage { get; set; }
+
+        public InvoiceDetailsModel Details { get; set; }
     }
 }

BTCPayServer/Models/PaymentRequestViewModels/ListPaymentRequestsViewModel.cs

@@ -134,7 +134,9 @@ namespace BTCPayServer.Models.PaymentRequestViewModels
         public string AmountCollectedFormatted { get; set; }
         public string AmountFormatted { get; set; }
         public bool AnyPendingInvoice { get; set; }
+        public bool PendingInvoiceHasPayments { get; set; }
         public string HubPath { get; set; }
+        public string StatusMessage { get; set; }
 
         public class PaymentRequestInvoice
         {

BTCPayServer/Models/ServerViewModels/ServicesViewModel.cs

@@ -20,5 +20,6 @@ namespace BTCPayServer.Models.ServerViewModels
         public List<OtherExternalService> OtherExternalServices { get; set; } = new List<OtherExternalService>();
         public List<OtherExternalService> TorHttpServices { get; set; } = new List<OtherExternalService>();
         public List<OtherExternalService> TorOtherServices { get; set; } = new List<OtherExternalService>();
+        public List<OtherExternalService> ExternalStorageServices { get; set; } = new List<OtherExternalService>();
     }
 }

BTCPayServer/Models/ServerViewModels/ViewFilesViewModel.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using BTCPayServer.Storage.Models;
+
+namespace BTCPayServer.Models.ServerViewModels
+{
+    public class ViewFilesViewModel
+    {
+        public List<StoredFile> Files { get; set; }
+        public string DirectFileUrl { get; set; }
+        public string SelectedFileId { get; set; }
+        public bool StorageConfigured { get; set; }
+    }
+}

BTCPayServer/Models/WalletViewModels/RescanWalletModel.cs

@@ -12,8 +12,7 @@ namespace BTCPayServer.Models.WalletViewModels
         public bool IsServerAdmin { get; set; }
         public bool IsSupportedByCurrency { get; set; }
         public bool IsFullySync { get; set; }
-        public bool IsSegwit { get; set; }
-        public bool Ok => IsServerAdmin && IsSupportedByCurrency && IsFullySync && IsSegwit;
+        public bool Ok => IsServerAdmin && IsSupportedByCurrency && IsFullySync;
 
         [Range(1000, 10_000)]
         public int BatchSize { get; set; } = 3000;

BTCPayServer/Models/WalletViewModels/WalletSendLedgerModel.cs

@@ -9,6 +9,7 @@ namespace BTCPayServer.Models.WalletViewModels
     {
         public int FeeSatoshiPerByte { get; set; }
         public bool SubstractFees { get; set; }
+        public bool DisableRBF { get; set; }
         public decimal Amount { get; set; }
         public string Destination { get; set; }
         public bool NoChange { get; set; }

BTCPayServer/Models/WalletViewModels/WalletSendModel.cs

@@ -31,10 +31,12 @@ namespace BTCPayServer.Models.WalletViewModels
 
         [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; }
         public string RateError { get; set; }
+        public bool SupportRBF { get; set; }
+        [Display(Name = "Disable RBF")]
+        public bool DisableRBF { get; set; }
     }
 }

BTCPayServer/PaymentRequest/PaymentRequestHub.cs

@@ -23,6 +23,8 @@ namespace BTCPayServer.PaymentRequest
         public const string PaymentReceived = "PaymentReceived";
         public const string InfoUpdated = "InfoUpdated";
         public const string InvoiceError = "InvoiceError";
+        public const string CancelInvoiceError = "CancelInvoiceError";
+        public const string InvoiceCancelled = "InvoiceCancelled";
 
         public PaymentRequestHub(PaymentRequestController paymentRequestController)
         {
@@ -61,6 +63,23 @@ namespace BTCPayServer.PaymentRequest
             }
         }
 
+        public async Task CancelUnpaidPendingInvoice()
+        {
+            _PaymentRequestController.ControllerContext.HttpContext = Context.GetHttpContext();
+            var result =
+                await _PaymentRequestController.CancelUnpaidPendingInvoice(Context.Items["pr-id"].ToString(), false);
+            switch (result)
+            {
+                case OkObjectResult okObjectResult:
+                    await Clients.Group(Context.Items["pr-id"].ToString()).SendCoreAsync(InvoiceCancelled, System.Array.Empty<object>());
+                    break;
+                    
+                default:
+                    await Clients.Caller.SendCoreAsync(CancelInvoiceError, System.Array.Empty<object>());
+                    break;
+            }
+        }
+
         public static string GetHubPath(HttpRequest request)
         {
             return request.GetRelativePathOrAbsolute("/payment-requests/hub");

BTCPayServer/PaymentRequest/PaymentRequestService.cs

@@ -80,6 +80,7 @@ namespace BTCPayServer.PaymentRequest
 
             var paymentStats = _AppService.GetContributionsByPaymentMethodId(blob.Currency, invoices, true);
             var amountDue = blob.Amount - paymentStats.TotalCurrency;
+            var pendingInvoice = invoices.SingleOrDefault(entity => entity.Status == InvoiceStatus.New);
 
             return new ViewPaymentRequestViewModel(pr)
             {
@@ -90,7 +91,9 @@ namespace BTCPayServer.PaymentRequest
                 AmountDueFormatted = _currencies.FormatCurrency(amountDue, blob.Currency),
                 CurrencyData = _currencies.GetCurrencyData(blob.Currency, true),
                 LastUpdated = DateTime.Now,
-                AnyPendingInvoice = invoices.Any(entity => entity.Status == InvoiceStatus.New),
+                AnyPendingInvoice = pendingInvoice != null,
+                PendingInvoiceHasPayments = pendingInvoice != null && 
+                                            pendingInvoice.ExceptionStatus != InvoiceExceptionStatus.None,
                 Invoices = invoices.Select(entity => new ViewPaymentRequestViewModel.PaymentRequestInvoice()
                 {
                     Id = entity.Id,

BTCPayServer/SearchString.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
@@ -15,35 +16,58 @@ namespace BTCPayServer
             str = str.Trim();
             _OriginalString = str.Trim();
             TextSearch = _OriginalString;
-            var splitted = str.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+            var splitted = str.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
             Filters
                 = splitted
-                    .Select(t => t.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries))
+                    .Select(t => t.Split(new char[] { ':' }, 2, StringSplitOptions.RemoveEmptyEntries))
                     .Where(kv => kv.Length == 2)
-                    .Select(kv => new KeyValuePair<string, string>(kv[0].ToLowerInvariant(), kv[1]))
+                    .Select(kv => new KeyValuePair<string, string>(kv[0].ToLowerInvariant().Trim(), kv[1]))
                     .ToMultiValueDictionary(o => o.Key, o => o.Value);
 
-            foreach(var filter in splitted)
-            {
-                if(filter.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Length == 2)
-                { 
-                    TextSearch = TextSearch.Replace(filter, string.Empty, StringComparison.InvariantCulture);
-                }
-            }
-            TextSearch = TextSearch.Trim();
+            var val = splitted.FirstOrDefault(a => a?.IndexOf(':', StringComparison.OrdinalIgnoreCase) == -1);
+            if (val != null)
+                TextSearch = val.Trim();
+            else
+                TextSearch = "";
         }
 
-        public string TextSearch
-        {
-            get;
-            private set;
-        }
-        
+        public string TextSearch { get; private set; }
+
         public MultiValueDictionary<string, string> Filters { get; private set; }
 
         public override string ToString()
         {
             return _OriginalString;
         }
+
+        internal string[] GetFilterArray(string key)
+        {
+            return Filters.ContainsKey(key) ? Filters[key].ToArray() : null;
+        }
+
+        internal bool? GetFilterBool(string key)
+        {
+            if (!Filters.ContainsKey(key))
+                return null;
+
+            return bool.TryParse(Filters[key].First(), out var r) ?
+                r : (bool?)null;
+        }
+
+        internal DateTimeOffset? GetFilterDate(string key, int timezoneOffset)
+        {
+            if (!Filters.ContainsKey(key))
+                return null;
+
+            var val = Filters[key].First();
+            var success = DateTimeOffset.TryParse(val, null as IFormatProvider, DateTimeStyles.AssumeUniversal, out var r);
+            if (success)
+            {
+                r = r.AddMinutes(timezoneOffset);
+                return r;
+            }
+
+            return null;
+        }
     }
 }

BTCPayServer/Security/BitpayAuthentication.cs

@@ -141,7 +141,7 @@ namespace BTCPayServer.Security
                         {
                             try
                             {
-                                token = JObject.Parse(body)?.Property("token")?.Value?.Value<string>();
+                                token = JObject.Parse(body)?.Property("token", StringComparison.OrdinalIgnoreCase)?.Value?.Value<string>();
                             }
                             catch { }
                         }

BTCPayServer/Services/HardwareWalletService.cs

@@ -118,7 +118,7 @@ namespace BTCPayServer.Services
                     if (network.NBitcoinNetwork.NetworkType == NetworkType.Mainnet)
                         throw new Exception($"The opened ledger app does not seems to support {network.NBitcoinNetwork.Name}.");
                 }
-                var fingerprint = onlyChaincode ? new byte[4] : (await ledger.GetWalletPubKeyAsync(account.Parent, cancellation: cancellation)).UncompressedPublicKey.Compress().Hash.ToBytes().Take(4).ToArray();
+                var fingerprint = onlyChaincode ? default : (await ledger.GetWalletPubKeyAsync(account.Parent, cancellation: cancellation)).UncompressedPublicKey.Compress().GetHDFingerPrint();
                 var extpubkey = new ExtPubKey(pubKey.UncompressedPublicKey.Compress(), pubKey.ChainCode, (byte)account.Indexes.Length, fingerprint, account.Indexes.Last()).GetWif(network.NBitcoinNetwork);
                 return extpubkey;
             }
@@ -164,17 +164,41 @@ namespace BTCPayServer.Services
             return foundKeyPath;
         }
 
-        public async Task<Transaction> SignTransactionAsync(SignatureRequest[] signatureRequests,
-                                                     Transaction unsigned,
-                                                     KeyPath changeKeyPath,
+        public async Task<PSBT> SignTransactionAsync(PSBT psbt, Script changeHint,
                                                      CancellationToken cancellationToken)
         {
             try
             {
+                var unsigned = psbt.GetGlobalTransaction();
+                var changeKeyPath = psbt.Outputs
+                                                .Where(o => changeHint == null ? true : changeHint == o.ScriptPubKey)
+                                                .Where(o => o.HDKeyPaths.Any())
+                                                .Select(o => o.HDKeyPaths.First().Value.Item2)
+                                                .FirstOrDefault();
+                var signatureRequests = psbt
+                    .Inputs
+                    .Where(o => o.HDKeyPaths.Any())
+                    .Where(o => !o.PartialSigs.ContainsKey(o.HDKeyPaths.First().Key))
+                    .Select(i => new SignatureRequest()
+                {
+                    InputCoin = i.GetSignableCoin(),
+                    InputTransaction = i.NonWitnessUtxo,
+                    KeyPath = i.HDKeyPaths.First().Value.Item2,
+                    PubKey = i.HDKeyPaths.First().Key
+                }).ToArray();
                 var signedTransaction = await Ledger.SignTransactionAsync(signatureRequests, unsigned, changeKeyPath, cancellationToken);
                 if (signedTransaction == null)
                     throw new Exception("The ledger failed to sign the transaction");
-                return signedTransaction;
+
+                psbt = psbt.Clone();
+                foreach (var signature in signatureRequests)
+                {
+                    var input = psbt.Inputs.FindIndexedInput(signature.InputCoin.Outpoint);
+                    if (input == null)
+                        continue;
+                    input.PartialSigs.Add(signature.PubKey, signature.Signature);
+                }
+                return psbt;
             }
             catch (Exception ex)
             {

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -1,4 +1,4 @@
-using DBreeze;
+using DBriize;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
@@ -27,8 +27,8 @@ namespace BTCPayServer.Services.Invoices
     {
 
 
-        private readonly DBreezeEngine _Engine;
-        public DBreezeEngine Engine
+        private readonly DBriizeEngine _Engine;
+        public DBriizeEngine Engine
         {
             get
             {
@@ -44,7 +44,7 @@ namespace BTCPayServer.Services.Invoices
 retry:
             try
             {
-                _Engine = new DBreezeEngine(dbreezePath);
+                _Engine = new DBriizeEngine(dbreezePath);
             }
             catch when (retryCount++ < 5) { goto retry; }
             _IndexerThread = new CustomThreadPool(1, "Invoice Indexer");
@@ -463,7 +463,7 @@ retry:
                 {
                     // 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); 
+                    return query.Where(x => false);
                 }
                 query = query.Where(i => ids.Contains(i.Id));
             }

BTCPayServer/Services/Mails/EmailSettings.cs

@@ -20,12 +20,12 @@ namespace BTCPayServer.Services.Mails
             get; set;
         }
 
-        public String Login
+        public string Login
         {
             get; set;
         }
-
-        public String Password
+        [DataType(DataType.Password)]
+        public string Password
         {
             get; set;
         }

BTCPayServer/Services/TorServices.cs

@@ -11,9 +11,11 @@ namespace BTCPayServer.Services
 {
     public class TorServices
     {
+        private readonly BTCPayNetworkProvider _networks;
         BTCPayServerOptions _Options;
-        public TorServices(BTCPayServerOptions options)
+        public TorServices(BTCPayServer.BTCPayNetworkProvider networks, BTCPayServerOptions options)
         {
+            _networks = networks;
             _Options = options;
         }
 
@@ -58,6 +60,11 @@ namespace BTCPayServer.Services
                         };
                         if (service.ServiceName.Equals("BTCPayServer", StringComparison.OrdinalIgnoreCase))
                             torService.ServiceType = TorServiceType.BTCPayServer;
+                        else if (TryParseP2PService(service.ServiceName, out var network))
+                        {
+                            torService.ServiceType = TorServiceType.P2P;
+                            torService.Network = network;
+                        }
                         result.Add(torService);
                     }
                     catch (Exception ex)
@@ -72,11 +79,22 @@ namespace BTCPayServer.Services
             }
             Services = result.ToArray();
         }
+
+        private bool TryParseP2PService(string name, out BTCPayNetwork network)
+        {
+            network = null;
+            var splitted = name.Trim().Split('-');
+            if (splitted.Length != 2 || splitted[1] != "P2P")
+                return false;
+            network = _networks.GetNetwork(splitted[0]);
+            return network != null;
+        }
     }
 
     public class TorService
     {
         public TorServiceType ServiceType { get; set; } = TorServiceType.Other;
+        public BTCPayNetwork Network { get; set; }
         public string Name { get; set; }
         public string OnionHost { get; set; }
         public int VirtualPort { get; set; }
@@ -85,6 +103,7 @@ namespace BTCPayServer.Services
     public enum TorServiceType
     {
         BTCPayServer,
+        P2P,
         Other
     }
 }

BTCPayServer/Storage/Models/StorageProvider.cs

@@ -0,0 +1,10 @@
+namespace BTCPayServer.Storage.Models
+{
+    public enum StorageProvider
+    {
+        AzureBlobStorage=0,
+        AmazonS3 =1,
+        GoogleCloudStorage =2,
+        FileSystem =3
+    }
+}

BTCPayServer/Storage/Models/StorageSettings.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Storage.Models
+{
+    public class StorageSettings
+    {
+        public StorageProvider Provider { get; set; }
+        public string ConfigurationStr { get; set; }
+        
+        [NotMapped]
+        public JObject Configuration
+        {
+            get => JsonConvert.DeserializeObject<JObject>(string.IsNullOrEmpty(ConfigurationStr) ? "{}" : ConfigurationStr);
+            set => ConfigurationStr = value.ToString();
+        }
+    }
+}

BTCPayServer/Storage/Models/StoredFile.cs

@@ -0,0 +1,21 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using BTCPayServer.Models;
+
+namespace BTCPayServer.Storage.Models
+{
+    public class StoredFile
+    {
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public string Id { get; set; }
+
+        public string FileName { get; set; }
+        public string StorageFileName { get; set; }
+        public DateTime Timestamp { get; set; }
+        public string ApplicationUserId { get; set; }
+        public ApplicationUser ApplicationUser
+        {
+            get; set;
+        }
+    }
+}

BTCPayServer/Storage/Services/FileService.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Storage.Services
+{
+    public class FileService
+    {
+        private readonly StoredFileRepository _FileRepository;
+        private readonly IEnumerable<IStorageProviderService> _providers;
+        private readonly SettingsRepository _SettingsRepository;
+
+        public FileService(StoredFileRepository fileRepository, IEnumerable<IStorageProviderService> providers,
+            SettingsRepository settingsRepository)
+        {
+            _FileRepository = fileRepository;
+            _providers = providers;
+            _SettingsRepository = settingsRepository;
+        }
+
+        public async Task<StoredFile> AddFile(IFormFile file, string userId)
+        {
+            var settings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
+            var provider = GetProvider(settings);
+
+            var storedFile = await provider.AddFile(file, settings);
+            storedFile.ApplicationUserId = userId;
+            await _FileRepository.AddFile(storedFile);
+            return storedFile;
+        }
+
+        public async Task<string> GetFileUrl(string fileId)
+        {
+            var settings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
+            var provider = GetProvider(settings);
+            var storedFile = await _FileRepository.GetFile(fileId);
+            return storedFile == null ? null: await provider.GetFileUrl(storedFile, settings);
+        }
+        
+        public async Task<string> GetTemporaryFileUrl(string fileId, DateTimeOffset expiry, bool isDownload)
+        {
+            var settings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
+            var provider = GetProvider(settings);
+            var storedFile = await _FileRepository.GetFile(fileId);
+            return storedFile == null ? null: await provider.GetTemporaryFileUrl(storedFile, settings,expiry,isDownload);
+        }
+
+        public async Task RemoveFile(string fileId, string userId)
+        {
+            var settings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
+            var provider = GetProvider(settings);
+            var storedFile = await _FileRepository.GetFile(fileId);
+            if (string.IsNullOrEmpty(userId) ||
+                storedFile.ApplicationUserId.Equals(userId, StringComparison.InvariantCultureIgnoreCase))
+            {
+                await provider.RemoveFile(storedFile, settings);
+                await _FileRepository.RemoveFile(storedFile);
+            }
+        }
+
+        private IStorageProviderService GetProvider(StorageSettings storageSettings)
+        {
+            return _providers.FirstOrDefault((service) => service.StorageProvider().Equals(storageSettings.Provider));
+        }
+    }
+}

BTCPayServer/Storage/Services/Providers/AmazonS3Storage/AmazonS3FileProviderService.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.AmazonS3Storage.Configuration;
+using TwentyTwenty.Storage;
+using TwentyTwenty.Storage.Amazon;
+
+namespace BTCPayServer.Storage.Services.Providers.AmazonS3Storage
+{
+    public class
+        AmazonS3FileProviderService : BaseTwentyTwentyStorageFileProviderServiceBase<AmazonS3StorageConfiguration>
+    {
+        public override StorageProvider StorageProvider()
+        {
+            return Storage.Models.StorageProvider.AmazonS3;
+        }
+
+        protected override Task<IStorageProvider> GetStorageProvider(AmazonS3StorageConfiguration configuration)
+        {
+            return Task.FromResult<IStorageProvider>(new AmazonStorageProvider(configuration));
+        }
+    }
+}

BTCPayServer/Storage/Services/Providers/AmazonS3Storage/Configuration/AmazonS3StorageConfiguration.cs

@@ -0,0 +1,10 @@
+using BTCPayServer.Storage.Services.Providers.Models;
+using TwentyTwenty.Storage.Amazon;
+
+namespace BTCPayServer.Storage.Services.Providers.AmazonS3Storage.Configuration
+ {
+     public class AmazonS3StorageConfiguration : AmazonProviderOptions, IBaseStorageConfiguration
+     {
+         public string ContainerName { get; set; }
+     }
+ }

BTCPayServer/Storage/Services/Providers/AzureBlobStorage/AzureBlobStorageFileProviderService.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration;
+using TwentyTwenty.Storage;
+using TwentyTwenty.Storage.Azure;
+
+namespace BTCPayServer.Storage.Services.Providers.AzureBlobStorage
+{
+    public class
+        AzureBlobStorageFileProviderService : BaseTwentyTwentyStorageFileProviderServiceBase<
+            AzureBlobStorageConfiguration>
+    {
+        public override StorageProvider StorageProvider()
+        {
+            return Storage.Models.StorageProvider.AzureBlobStorage;
+        }
+        protected override Task<IStorageProvider> GetStorageProvider(AzureBlobStorageConfiguration configuration)
+        {
+            return Task.FromResult<IStorageProvider>(new AzureStorageProvider(configuration));
+        }
+    }
+}

BTCPayServer/Storage/Services/Providers/AzureBlobStorage/Configuration/AzureBlobStorageConfiguration.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Storage.Services.Providers.Models;
+using Microsoft.AspNetCore.Mvc;
+using TwentyTwenty.Storage.Azure;
+
+namespace BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration
+{
+    [ModelMetadataType(typeof(AzureBlobStorageConfigurationMetadata))]
+    public class AzureBlobStorageConfiguration : AzureProviderOptions, IBaseStorageConfiguration
+    {
+        [Required]
+        [MinLength(3)]
+        [MaxLength(63)]
+        [RegularExpression(@"[a-z0-9-]+",
+            ErrorMessage = "Characters must be lowercase or digits or -")]
+        public string ContainerName { get; set; }
+    }
+}

BTCPayServer/Storage/Services/Providers/AzureBlobStorage/Configuration/AzureBlobStorageConfigurationMetadata.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration
+{
+    public class AzureBlobStorageConfigurationMetadata
+    {
+        [Required]
+        [AzureBlobStorageConnectionStringValidator]
+        public string ConnectionString { get; set; }
+    }
+}

BTCPayServer/Storage/Services/Providers/AzureBlobStorage/Configuration/AzureBlobStorageConnectionStringValidator.cs

@@ -0,0 +1,22 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Microsoft.WindowsAzure.Storage;
+
+namespace BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration
+{
+    public class AzureBlobStorageConnectionStringValidator : ValidationAttribute
+    {
+        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
+        {
+            try
+            {
+                CloudStorageAccount.Parse(value as string);
+                return ValidationResult.Success;
+            }
+            catch (Exception e)
+            {
+                return new ValidationResult(e.Message);
+            }
+        }
+    }
+}

BTCPayServer/Storage/Services/Providers/BaseTwentyTwentyStorageFileProviderServiceBase.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Threading.Tasks;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.Models;
+using Microsoft.AspNetCore.Http;
+using TwentyTwenty.Storage;
+
+namespace BTCPayServer.Storage.Services.Providers
+{
+    public abstract class
+        BaseTwentyTwentyStorageFileProviderServiceBase<TStorageConfiguration> : IStorageProviderService
+        where TStorageConfiguration : IBaseStorageConfiguration
+    {
+        public abstract StorageProvider StorageProvider();
+
+        public async Task<StoredFile> AddFile(IFormFile file, StorageSettings configuration)
+        {
+            //respect https://www.microsoftpressstore.com/articles/article.aspx?p=2224058&seqNum=8 in naming
+            var storageFileName = $"{Guid.NewGuid()}-{file.FileName.ToLowerInvariant()}";
+            var providerConfiguration = GetProviderConfiguration(configuration);
+            var provider = await GetStorageProvider(providerConfiguration);
+            using (var fileStream = file.OpenReadStream())
+            {
+                await provider.SaveBlobStreamAsync(providerConfiguration.ContainerName, storageFileName, fileStream,
+                    new BlobProperties()
+                    {
+                        ContentType = file.ContentType,
+                        ContentDisposition = file.ContentDisposition,
+                        Security = BlobSecurity.Public,
+                    });
+            }
+
+            return new StoredFile()
+            {
+                Timestamp = DateTime.Now,
+                FileName = file.FileName,
+                StorageFileName = storageFileName
+            };
+        }
+
+        public virtual async Task<string> GetFileUrl(StoredFile storedFile, StorageSettings configuration)
+        {
+            var providerConfiguration = GetProviderConfiguration(configuration);
+            var provider = await GetStorageProvider(providerConfiguration);
+            return provider.GetBlobUrl(providerConfiguration.ContainerName, storedFile.StorageFileName);
+        }
+
+        public virtual async Task<string> GetTemporaryFileUrl(StoredFile storedFile, StorageSettings configuration,
+            DateTimeOffset expiry, bool isDownload, BlobUrlAccess access = BlobUrlAccess.Read)
+        {
+            var providerConfiguration = GetProviderConfiguration(configuration);
+            var provider = await GetStorageProvider(providerConfiguration);
+            if (isDownload)
+            {
+                var descriptor =
+                    await provider.GetBlobDescriptorAsync(providerConfiguration.ContainerName,
+                        storedFile.StorageFileName);
+                return provider.GetBlobSasUrl(providerConfiguration.ContainerName, storedFile.StorageFileName, expiry,
+                    true, storedFile.FileName, descriptor.ContentType, access);
+            }
+
+            return provider.GetBlobSasUrl(providerConfiguration.ContainerName, storedFile.StorageFileName, expiry,
+                false, null, null, access);
+        }
+
+        public async Task RemoveFile(StoredFile storedFile, StorageSettings configuration)
+        {
+            var providerConfiguration = GetProviderConfiguration(configuration);
+            var provider = await GetStorageProvider(providerConfiguration);
+            await provider.DeleteBlobAsync(providerConfiguration.ContainerName, storedFile.StorageFileName);
+        }
+
+        public TStorageConfiguration GetProviderConfiguration(StorageSettings configuration)
+        {
+            return configuration.Configuration.ToObject<TStorageConfiguration>();
+        }
+
+
+        protected abstract Task<IStorageProvider> GetStorageProvider(TStorageConfiguration configuration);
+    }
+}

BTCPayServer/Storage/Services/Providers/FileSystemStorage/Configuration/FileSystemStorageConfiguration.cs

@@ -0,0 +1,9 @@
+using BTCPayServer.Storage.Services.Providers.Models;
+
+namespace BTCPayServer.Storage.Services.Providers.FileSystemStorage.Configuration
+{
+    public class FileSystemStorageConfiguration : IBaseStorageConfiguration
+    {
+        public string ContainerName { get; set; } = string.Empty;
+    }
+}

BTCPayServer/Storage/Services/Providers/FileSystemStorage/FileSystemFileProviderService.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using BTCPayServer.Configuration;
+using BTCPayServer.Services;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage.Configuration;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using TwentyTwenty.Storage;
+using TwentyTwenty.Storage.Local;
+
+namespace BTCPayServer.Storage.Services.Providers.FileSystemStorage
+{
+    public class
+        FileSystemFileProviderService : BaseTwentyTwentyStorageFileProviderServiceBase<FileSystemStorageConfiguration>
+    {
+        private readonly BTCPayServerEnvironment _BtcPayServerEnvironment;
+        private readonly BTCPayServerOptions _Options;
+        private readonly IHttpContextAccessor _HttpContextAccessor;
+
+        public FileSystemFileProviderService(BTCPayServerEnvironment btcPayServerEnvironment,
+            BTCPayServerOptions options, IHttpContextAccessor httpContextAccessor)
+        {
+            _BtcPayServerEnvironment = btcPayServerEnvironment;
+            _Options = options;
+            _HttpContextAccessor = httpContextAccessor;
+        }
+        public const string LocalStorageDirectoryName = "LocalStorage";
+
+        public static string GetStorageDir(BTCPayServerOptions options)
+        {
+            return Path.Combine(options.DataDir, LocalStorageDirectoryName);
+        }
+
+        public override StorageProvider StorageProvider()
+        {
+            return Storage.Models.StorageProvider.FileSystem;
+        }
+
+        protected override Task<IStorageProvider> GetStorageProvider(FileSystemStorageConfiguration configuration)
+        {
+            return Task.FromResult<IStorageProvider>(
+                new LocalStorageProvider(new DirectoryInfo(GetStorageDir(_Options)).FullName));
+        }
+
+        public override async Task<string> GetFileUrl(StoredFile storedFile, StorageSettings configuration)
+        {
+            var baseResult = await base.GetFileUrl(storedFile, configuration);
+            var url =
+                _HttpContextAccessor.HttpContext.Request.IsOnion()
+                    ? _BtcPayServerEnvironment.OnionUrl
+                    : $"{_BtcPayServerEnvironment.ExpectedProtocol}://" +
+                      $"{_BtcPayServerEnvironment.ExpectedHost}" +
+                      $"{_Options.RootPath}{LocalStorageDirectoryName}";
+            return baseResult.Replace(new DirectoryInfo(GetStorageDir(_Options)).FullName, url,
+                StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        public override Task<string> GetTemporaryFileUrl(StoredFile storedFile, StorageSettings configuration, DateTimeOffset expiry, bool isDownload,
+            BlobUrlAccess access = BlobUrlAccess.Read)
+        {
+            return GetFileUrl(storedFile, configuration);
+        }
+    }
+}

BTCPayServer/Storage/Services/Providers/GoogleCloudStorage/Configuration/GoogleCloudStorageConfiguration.cs

@@ -0,0 +1,11 @@
+using BTCPayServer.Storage.Services.Providers.Models;
+using TwentyTwenty.Storage.Google;
+
+namespace BTCPayServer.Storage.Services.Providers.GoogleCloudStorage.Configuration
+{
+    public class GoogleCloudStorageConfiguration : GoogleProviderOptions, IBaseStorageConfiguration
+    {
+        public string JsonCredentials{ get; set; } 
+        public string ContainerName { get; set; }
+    }
+}

BTCPayServer/Storage/Services/Providers/GoogleCloudStorage/GoogleCloudStorageFileProviderService.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using BTCPayServer.Storage.Models;
+using BTCPayServer.Storage.Services.Providers.GoogleCloudStorage.Configuration;
+using Google.Apis.Auth.OAuth2;
+using TwentyTwenty.Storage;
+using TwentyTwenty.Storage.Google;
+
+namespace BTCPayServer.Storage.Services.Providers.GoogleCloudStorage
+{
+    public class
+        GoogleCloudStorageFileProviderService : BaseTwentyTwentyStorageFileProviderServiceBase<
+            GoogleCloudStorageConfiguration>
+    {
+        public override StorageProvider StorageProvider()
+        {
+            return Storage.Models.StorageProvider.GoogleCloudStorage;
+        }
+
+        protected override Task<IStorageProvider> GetStorageProvider(
+            GoogleCloudStorageConfiguration configuration)
+        {
+            return Task.FromResult<IStorageProvider>(new GoogleStorageProvider(GoogleCredential.FromJson(configuration.JsonCredentials), configuration));
+        }
+    }
+}

BTCPayServer/Storage/Services/Providers/IStorageProviderService.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Threading.Tasks;
+using BTCPayServer.Storage.Models;
+using Microsoft.AspNetCore.Http;
+using TwentyTwenty.Storage;
+
+namespace BTCPayServer.Storage.Services.Providers
+{
+    public interface IStorageProviderService
+    {
+        Task<StoredFile> AddFile(IFormFile formFile, StorageSettings configuration);
+        Task RemoveFile(StoredFile storedFile, StorageSettings configuration);
+        Task<string> GetFileUrl(StoredFile storedFile, StorageSettings configuration);
+        Task<string> GetTemporaryFileUrl(StoredFile storedFile, StorageSettings configuration,
+            DateTimeOffset expiry, bool isDownload, BlobUrlAccess access = BlobUrlAccess.Read);
+        StorageProvider StorageProvider();
+    }
+}

BTCPayServer/Storage/Services/Providers/Models/IBaseStorageConfiguration.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Storage.Services.Providers.Models
+{
+    public interface IBaseStorageConfiguration
+    {
+        string ContainerName { get; set; }
+    }
+}

BTCPayServer/Storage/Services/StoredFileRepository.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Storage.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace BTCPayServer.Storage.Services
+{
+    public class StoredFileRepository
+    {
+        private readonly ApplicationDbContextFactory _ApplicationDbContextFactory;
+
+        public StoredFileRepository(ApplicationDbContextFactory applicationDbContextFactory)
+        {
+            _ApplicationDbContextFactory = applicationDbContextFactory;
+        }
+
+        public async Task<StoredFile> GetFile(string fileId)
+        {
+            var filesResult = await GetFiles(new FilesQuery() {Id = new string[] {fileId}});
+            return filesResult.FirstOrDefault();
+        }
+
+        public async Task<List<StoredFile>> GetFiles(FilesQuery filesQuery = null)
+        {
+            if (filesQuery == null)
+            {
+                filesQuery = new FilesQuery();
+            }
+
+            using (var context = _ApplicationDbContextFactory.CreateContext())
+            {
+                return await context.Files
+                    .Include(file => file.ApplicationUser)
+                    .Where(file =>
+                        (!filesQuery.Id.Any() || filesQuery.Id.Contains(file.Id)) &&
+                        (!filesQuery.UserIds.Any() || filesQuery.UserIds.Contains(file.ApplicationUserId)))
+                    .ToListAsync();
+            }
+        }
+
+        public async Task RemoveFile(StoredFile file)
+        {
+            using (var context = _ApplicationDbContextFactory.CreateContext())
+            {
+                context.Attach(file);
+                context.Files.Remove(file);
+                await context.SaveChangesAsync();
+            }
+        }
+
+        public async Task AddFile(StoredFile storedFile)
+        {
+            using (var context = _ApplicationDbContextFactory.CreateContext())
+            {
+                await context.AddAsync(storedFile);
+                await context.SaveChangesAsync();
+            }
+        }
+
+        public class FilesQuery
+        {
+            public string[] Id { get; set; } = Array.Empty<string>();
+            public string[] UserIds { get; set; } = Array.Empty<string>();
+        }
+    }
+}

BTCPayServer/Storage/StorageExtensions.cs

@@ -0,0 +1,50 @@
+using System.IO;
+using BTCPayServer.Configuration;
+using BTCPayServer.Storage.Services;
+using BTCPayServer.Storage.Services.Providers;
+using BTCPayServer.Storage.Services.Providers.AmazonS3Storage;
+using BTCPayServer.Storage.Services.Providers.AzureBlobStorage;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage;
+using BTCPayServer.Storage.Services.Providers.GoogleCloudStorage;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.FileProviders;
+
+namespace BTCPayServer.Storage
+{
+    public static class StorageExtensions
+    {
+        public static void AddProviderStorage(this IServiceCollection serviceCollection)
+        {
+            serviceCollection.AddSingleton<StoredFileRepository>();
+            serviceCollection.AddSingleton<FileService>();
+//            serviceCollection.AddSingleton<IStorageProviderService, AmazonS3FileProviderService>();
+            serviceCollection.AddSingleton<IStorageProviderService, AzureBlobStorageFileProviderService>();
+            serviceCollection.AddSingleton<IStorageProviderService, FileSystemFileProviderService>();
+//            serviceCollection.AddSingleton<IStorageProviderService, GoogleCloudStorageFileProviderService>();
+        }
+
+        public static void UseProviderStorage(this IApplicationBuilder builder, BTCPayServerOptions options)
+        {
+            var dir = FileSystemFileProviderService.GetStorageDir(options);
+
+            DirectoryInfo dirInfo;
+            if (!Directory.Exists(dir))
+            {
+                dirInfo = Directory.CreateDirectory(dir);
+            }
+            else
+            {
+                dirInfo = new DirectoryInfo(dir);
+            }
+
+            builder.UseStaticFiles(new StaticFileOptions()
+            {
+                ServeUnknownFileTypes = true,
+                RequestPath = new PathString($"/{FileSystemFileProviderService.LocalStorageDirectoryName}"),
+                FileProvider = new PhysicalFileProvider(dirInfo.FullName)
+            });
+        }
+    }
+}

BTCPayServer/Storage/ViewModels/ChooseStorageViewModel.cs

@@ -0,0 +1,10 @@
+using BTCPayServer.Storage.Models;
+
+namespace BTCPayServer.Storage.ViewModels
+{
+    public class ChooseStorageViewModel
+    {
+        public StorageProvider Provider { get; set; }
+        public bool ShowChangeWarning { get; set; }
+    }
+}

BTCPayServer/U2F/Models/AddU2FDeviceViewModel.cs

@@ -0,0 +1,12 @@
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class AddU2FDeviceViewModel
+    {
+        public string AppId{ get; set; }
+        public string Challenge { get; set; }
+        public string Version { get; set; }
+        public string DeviceResponse { get; set; }
+
+        public string Name { get; set; }
+    }
+}

BTCPayServer/U2F/Models/LoginWithU2FViewModel.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class LoginWithU2FViewModel
+    {
+        public string UserId { get; set; }
+        [Required]
+        [Display(Name = "App id")]
+        public string AppId { get; set; }
+
+        [Required]
+        [Display(Name = "Version")]
+        public string Version { get; set; }
+
+        [Required]
+        [Display(Name = "Device Response")]
+        public string DeviceResponse { get; set; }
+
+        [Display(Name = "Challenges")]
+        public string Challenges { get; set; }
+
+        [Display(Name = "Challenge")]
+        public string Challenge { get; set; }
+
+        public bool RememberMe { get; set; }
+    }
+}

BTCPayServer/U2F/Models/ServerChallenge.cs

@@ -0,0 +1,10 @@
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class ServerChallenge
+    {
+        public string challenge { get; set; }
+        public string version { get; set; }
+        public string appId { get; set; }
+        public string keyHandle { get; set; }
+    }
+}

BTCPayServer/U2F/Models/ServerRegisterResponse.cs

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class ServerRegisterResponse
+    {
+        public string AppId { get; set; }
+        public string Challenge { get; set; }
+        public string Version { get; set; }
+    }
+}

BTCPayServer/U2F/Models/U2FAuthenticationViewModel.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class U2FAuthenticationViewModel
+    {
+        public string StatusMessage { get; set; }
+        public List<U2FDevice> Devices { get; set; }
+    }
+}

BTCPayServer/U2F/Models/U2FDevice.cs

@@ -0,0 +1,24 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Models;
+
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class U2FDevice
+    {
+        public string Id { get; set; }
+
+        public string Name { get; set; }
+
+        [Required] public byte[] KeyHandle { get; set; }
+
+        [Required] public byte[] PublicKey { get; set; }
+
+        [Required] public byte[] AttestationCert { get; set; }
+
+        [Required] public int Counter { get; set; }
+
+        public string ApplicationUserId { get; set; }
+        public ApplicationUser ApplicationUser { get; set; }
+    }
+}

BTCPayServer/U2F/Models/U2FDeviceAuthenticationRequest.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace BTCPayServer.Services.U2F.Models
+{
+    public class U2FDeviceAuthenticationRequest
+    {
+        public string KeyHandle { get; set; }
+
+        [Required] public string Challenge { get; set; }
+
+        [Required] [StringLength(200)] public string AppId { get; set; }
+
+        [Required] [StringLength(50)] public string Version { get; set; }
+    }
+}

BTCPayServer/U2F/U2FService.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models;
+using BTCPayServer.Services.U2F.Models;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using NBitcoin;
+using U2F.Core.Models;
+using U2F.Core.Utils;
+
+namespace BTCPayServer.Services.U2F
+{
+    public class U2FService
+    {
+        private readonly ApplicationDbContextFactory _contextFactory;
+
+        private ConcurrentDictionary<string, List<U2FDeviceAuthenticationRequest>> UserAuthenticationRequests
+        {
+            get;
+            set;
+        }
+            = new ConcurrentDictionary<string, List<U2FDeviceAuthenticationRequest>>();
+
+        public U2FService(ApplicationDbContextFactory contextFactory)
+        {
+            _contextFactory = contextFactory;
+        }
+
+        public async Task<List<U2FDevice>> GetDevices(string userId)
+        {
+            using (var context = _contextFactory.CreateContext())
+            {
+                return await context.U2FDevices
+                    .Where(device => device.ApplicationUserId.Equals(userId, StringComparison.InvariantCulture))
+                    .ToListAsync();
+            }
+        }
+
+        public async Task RemoveDevice(string id, string userId)
+        {
+            using (var context = _contextFactory.CreateContext())
+            {
+                var device = await context.U2FDevices.FindAsync(id);
+                if (device == null || !device.ApplicationUserId.Equals(userId, StringComparison.InvariantCulture))
+                {
+                    return;
+                }
+
+                context.U2FDevices.Remove(device);
+                await context.SaveChangesAsync();
+            }
+        }
+        
+        public async Task<bool> HasDevices(string userId)
+        {
+            using (var context = _contextFactory.CreateContext())
+            {
+                return await context.U2FDevices.AnyAsync(fDevice => fDevice.ApplicationUserId.Equals(userId, StringComparison.InvariantCulture));
+            }
+        }
+        
+
+        public ServerRegisterResponse StartDeviceRegistration(string userId, string appId)
+        {
+            var startedRegistration = global::U2F.Core.Crypto.U2F.StartRegistration(appId);
+
+            UserAuthenticationRequests.AddOrReplace(userId, new List<U2FDeviceAuthenticationRequest>()
+            {
+                new U2FDeviceAuthenticationRequest()
+                {
+                    AppId = startedRegistration.AppId,
+                    Challenge = startedRegistration.Challenge,
+                    Version = global::U2F.Core.Crypto.U2F.U2FVersion,
+                }
+            });
+
+            return new ServerRegisterResponse
+            {
+                AppId = startedRegistration.AppId,
+                Challenge = startedRegistration.Challenge,
+                Version = startedRegistration.Version
+            };
+        }
+
+        public async Task<bool> CompleteRegistration(string userId, string deviceResponse, string name)
+        {
+            if (string.IsNullOrWhiteSpace(deviceResponse))
+                return false;
+
+            if (!UserAuthenticationRequests.ContainsKey(userId) || !UserAuthenticationRequests[userId].Any())
+            {
+                return false;
+            }
+
+            var registerResponse = RegisterResponse.FromJson<RegisterResponse>(deviceResponse);
+
+            //There is only 1 request when registering device
+            var authenticationRequest = UserAuthenticationRequests[userId].First();
+
+            var startedRegistration =
+                new StartedRegistration(authenticationRequest.Challenge, authenticationRequest.AppId);
+            var registration = global::U2F.Core.Crypto.U2F.FinishRegistration(startedRegistration, registerResponse);
+
+            UserAuthenticationRequests.AddOrReplace(userId, new List<U2FDeviceAuthenticationRequest>());
+            using (var context = _contextFactory.CreateContext())
+            {
+                var duplicate = context.U2FDevices.Any(device =>
+                    device.ApplicationUserId.Equals(userId, StringComparison.InvariantCulture) &&
+                    device.KeyHandle.Equals(registration.KeyHandle) &&
+                    device.PublicKey.Equals(registration.PublicKey));
+
+                if (duplicate)
+                {
+                    throw new InvalidOperationException("The U2F Device has already been registered with this user");
+                }
+                
+                await context.U2FDevices.AddAsync(new U2FDevice()
+                {
+                    AttestationCert = registration.AttestationCert,
+                    Counter = Convert.ToInt32(registration.Counter),
+                    Name = name,
+                    KeyHandle = registration.KeyHandle,
+                    PublicKey = registration.PublicKey,
+                    ApplicationUserId = userId
+                });
+
+                await context.SaveChangesAsync();
+            }
+
+            return true;
+        }
+
+        public async Task<bool> AuthenticateUser(string userId, string deviceResponse)
+        {
+            if (string.IsNullOrWhiteSpace(userId) || string.IsNullOrWhiteSpace(deviceResponse))
+                return false;
+
+            var authenticateResponse =
+                AuthenticateResponse.FromJson<AuthenticateResponse>(deviceResponse);
+
+            using (var context = _contextFactory.CreateContext())
+            {
+                var device = await context.U2FDevices.SingleOrDefaultAsync(fDevice =>
+                    fDevice.ApplicationUserId.Equals(userId, StringComparison.InvariantCulture) &&
+                    fDevice.KeyHandle.SequenceEqual(authenticateResponse.KeyHandle.Base64StringToByteArray()));
+
+                if (device == null)
+                    return false;
+
+                // User will have a authentication request for each device they have registered so get the one that matches the device key handle
+
+                var authenticationRequest =
+                    UserAuthenticationRequests[userId].First(f =>
+                        f.KeyHandle.Equals(authenticateResponse.KeyHandle, StringComparison.InvariantCulture));
+                var registration = new DeviceRegistration(device.KeyHandle, device.PublicKey,
+                    device.AttestationCert, Convert.ToUInt32(device.Counter));
+
+                var authentication = new StartedAuthentication(authenticationRequest.Challenge,
+                    authenticationRequest.AppId, authenticationRequest.KeyHandle);
+
+                global::U2F.Core.Crypto.U2F.FinishAuthentication(authentication, authenticateResponse, registration);
+
+
+                UserAuthenticationRequests.AddOrReplace(userId, new List<U2FDeviceAuthenticationRequest>());
+
+                device.Counter = Convert.ToInt32(registration.Counter);
+                await context.SaveChangesAsync();
+            }
+
+            return true;
+        }
+
+        public async Task<List<ServerChallenge>> GenerateDeviceChallenges(string userId, string appId)
+        {
+            using (var context = _contextFactory.CreateContext())
+            {
+                var devices = await context.U2FDevices.Where(fDevice =>
+                    fDevice.ApplicationUserId.Equals(userId, StringComparison.InvariantCulture)).ToListAsync();
+
+                if (devices.Count == 0)
+                    return null;
+
+                var requests = new List<U2FDeviceAuthenticationRequest>();
+
+
+
+                var serverChallenges = new List<ServerChallenge>();
+                foreach (var registeredDevice in devices)
+                {
+                   var challenge =  global::U2F.Core.Crypto.U2F.StartAuthentication(appId,
+                       new DeviceRegistration(registeredDevice.KeyHandle, registeredDevice.PublicKey,
+                           registeredDevice.AttestationCert, (uint)registeredDevice.Counter));
+                   serverChallenges.Add(new ServerChallenge()
+                   {
+                       challenge = challenge.Challenge,
+                       appId = challenge.AppId,
+                       version = challenge.Version,
+                       keyHandle = challenge.KeyHandle
+                   });
+                   
+                    requests.Add(
+                        new U2FDeviceAuthenticationRequest()
+                        {
+                            AppId = appId,
+                            Challenge = challenge.Challenge,
+                            KeyHandle = registeredDevice.KeyHandle.ByteArrayToBase64String(),
+                            Version = global::U2F.Core.Crypto.U2F.U2FVersion
+                        });
+                }
+
+                UserAuthenticationRequests.AddOrReplace(userId, requests);
+                return serverChallenges;
+            }
+        }
+    }
+}

BTCPayServer/Views/Account/LoginWith2fa.cshtml

@@ -1,45 +1,37 @@
 @model LoginWith2faViewModel
-@{
-    ViewData["Title"] = "Two-factor authentication";
-}
 
 <section>
-    <div class="container">
+    <div class="container-fluid">
         <div class="row">
             <div class="col-lg-12 text-center">
-                <h2 class="section-heading">@ViewData["Title"]</h2>
+                <h2 class="section-heading">Two-factor authentication</h2>
                 <hr class="primary">
             </div>
         </div>
         <div class="row">
-            <div class="col-md-4"></div>
-            <div class="col-md-4">
-                <form method="post" asp-route-returnUrl="@ViewData["ReturnUrl"]">
-                    <input asp-for="RememberMe" type="hidden" />
-                    <div asp-validation-summary="All" class="text-danger"></div>
-                    <div class="form-group">
-                        <label asp-for="TwoFactorCode"></label>
-                        <input asp-for="TwoFactorCode" class="form-control" autocomplete="off" />
-                        <span asp-validation-for="TwoFactorCode" class="text-danger"></span>
+            <form  class="col-12" method="post" asp-route-returnUrl="@ViewData["ReturnUrl"]" asp-action="LoginWith2fa">
+                <input asp-for="RememberMe" type="hidden"/>
+                <div class="form-group">
+                    <label asp-for="TwoFactorCode"></label>
+                    <input asp-for="TwoFactorCode" class="form-control" autocomplete="off"/>
+                    <span asp-validation-for="TwoFactorCode" class="text-danger"></span>
+                </div>
+                <div class="form-group">
+                    <div class="checkbox">
+                        <label asp-for="RememberMachine">
+                            <input asp-for="RememberMachine"/>
+                            @Html.DisplayNameFor(m => m.RememberMachine)
+                        </label>
                     </div>
-                    <div class="form-group">
-                        <div class="checkbox">
-                            <label asp-for="RememberMachine">
-                                <input asp-for="RememberMachine" />
-                                @Html.DisplayNameFor(m => m.RememberMachine)
-                            </label>
-                        </div>
-                    </div>
-                    <div class="form-group">
-                        <button type="submit" class="btn btn-primary">Log in</button>
-                    </div>
-                </form>
-            </div>
-            <div class="col-md-4"></div>
+                </div>
+                <div class="form-group">
+                    <button type="submit" class="btn btn-primary">Log in</button>
+                </div>
+                
+            </form>
         </div>
         <div class="row">
-            <div class="col-md-4"></div>
-            <div class="col-md-4">
+            <div class="col-12">
                 <p>
                     Don't have access to your authenticator device? You can
                     <a asp-action="LoginWithRecoveryCode" asp-route-returnUrl="@ViewData["ReturnUrl"]">log in with a recovery code</a>.
@@ -48,6 +40,7 @@
         </div>
     </div>
 </section>
+
 @section Scripts {
     @await Html.PartialAsync("_ValidationScriptsPartial")
 }

BTCPayServer/Views/Account/LoginWithRecoveryCode.cshtml

@@ -3,26 +3,35 @@
     ViewData["Title"] = "Recovery code verification";
 }
 
-<h2>@ViewData["Title"]</h2>
-<hr />
-<p>
-    You have requested to login with a recovery code. This login will not be remembered until you provide
-    an authenticator app code at login or disable 2FA and login again.
-</p>
-<div class="row">
-    <div class="col-md-4">
-        <form method="post">
-            <div asp-validation-summary="All" class="text-danger"></div>
-            <div class="form-group">
-                <label asp-for="RecoveryCode"></label>
-                <input asp-for="RecoveryCode" class="form-control" autocomplete="off" />
-                <span asp-validation-for="RecoveryCode" class="text-danger"></span>
+
+
+<section>
+    <div class="container">
+        <div class="row">
+            <div class="col-lg-12 text-center">
+                <h2 class="section-heading">@ViewData["Title"]</h2>
+                <hr class="primary">
+                <p>
+                    You have requested to login with a recovery code. This login will not be remembered until you provide
+                    an authenticator app code at login or disable 2FA and login again.
+                </p>
             </div>
-            <button type="submit" class="btn btn-primary">Log in</button>
-        </form>
+        </div>
+        <div class="row">
+            <form method="post" class="col-12">
+                <div asp-validation-summary="All" class="text-danger"></div>
+                <div class="form-group">
+                    <label asp-for="RecoveryCode"></label>
+                    <input asp-for="RecoveryCode" class="form-control" autocomplete="off" />
+                    <span asp-validation-for="RecoveryCode" class="text-danger"></span>
+                </div>
+                <button type="submit" class="btn btn-primary">Log in</button>
+            </form>
+        </div>
     </div>
-</div>
+</section>
+
 
 @section Scripts {
     @await Html.PartialAsync("_ValidationScriptsPartial")
-}
+}

BTCPayServer/Views/Account/LoginWithU2F.cshtml

@@ -0,0 +1,53 @@
+@model BTCPayServer.Services.U2F.Models.LoginWithU2FViewModel
+
+<form id="u2fForm" asp-action="LoginWithU2F" method="post" asp-route-returnUrl="@ViewData["ReturnUrl"]">
+    <input type="hidden" asp-for="Version" />
+    <input type="hidden" asp-for="Challenge" />
+    <input type="hidden" asp-for="AppId" />
+    <input type="hidden" asp-for="DeviceResponse" />
+    <input type="hidden" asp-for="Challenges" />
+    <input type="hidden" asp-for="UserId" />
+    <input type="hidden" asp-for="RememberMe" />
+</form>
+
+<section>
+    <div class="container-fluid">
+        <div class="row">
+            <div class="col-lg-12 text-center">
+                <h2 class="section-heading"><span class="fa fa-spinner fa-spin"></span>U2F Authentication</h2>
+                <hr class="primary">
+                
+                <p>Insert your U2F device or a hardware wallet into your computer's USB port. If it has a button, tap on it.</p>
+            </div>
+        </div>
+        <div class="row">
+            <a id="error-response" class="text-danger" href="javascript:window.location.reload()"> </a>
+        </div>
+    </div>
+</section>
+
+<script src="~/vendor/u2f/u2f-api-1.1.js"></script>
+<script type="text/javascript">
+    var errorMap = {
+        1: 'Unknown error, try again',
+        2: "Bad request error, try again",
+        3: "This key isn't supported, please try another one",
+        4: 'The device is already registered, please login',
+        5: 'Authentication timed out. Please reload to try again.'
+    };
+    setTimeout(function() {
+        window.u2f.sign(
+            "@Model.AppId",
+            "@Model.Challenge",
+            @Html.Raw(@Model.Challenges), function (data) {
+                if (data.errorCode) {
+                    $("#error-response").text(errorMap[data.errorCode]);
+                    return;
+                }
+                $('#DeviceResponse').val(JSON.stringify(data));
+                $('#u2fForm').submit();
+
+                return "";
+            });
+    }, 1000);
+</script>

BTCPayServer/Views/Account/SecondaryLogin.cshtml

@@ -0,0 +1,47 @@
+@model SecondaryLoginViewModel
+@{
+    ViewData["Title"] = "Two-factor/U2F authentication";
+}
+
+<section>
+    <div class="container">
+        @if (Model.LoginWith2FaViewModel != null && Model.LoginWithU2FViewModel != null)
+        {
+            <div class="row">
+                <div class="col-lg-12 text-center">
+                    <h2 class="section-heading">@ViewData["Title"]</h2>
+                    <hr class="primary">
+                    
+                    <div asp-validation-summary="ModelOnly" class="text-danger"></div>
+                </div>
+            </div>
+        }else if (Model.LoginWith2FaViewModel == null && Model.LoginWithU2FViewModel == null)
+        {
+            <div class="row">
+                <div class="col-lg-12 text-center">
+                    <h2 class="section-heading bg-danger">Both 2FA and U2F Authentication Methods are not available. Please go to the https endpoint</h2>
+                    <hr class="danger">
+                </div>
+            </div>
+        }
+        
+        
+        <div class="row justify-content-center">
+            @if (Model.LoginWith2FaViewModel != null)
+            {
+                <div class="col-sm-12 col-md-6">
+                    <partial name="Loginwith2fa" model="@Model.LoginWith2FaViewModel"/>
+                </div>
+            }
+            @if (Model.LoginWithU2FViewModel != null)
+            {
+                <div class="col-sm-12 col-md-6">
+                    <partial name="LoginWithU2F" model="@Model.LoginWithU2FViewModel"/>
+                </div>
+            }
+        </div>
+    </div>
+</section>
+@section Scripts {
+    @await Html.PartialAsync("_ValidationScriptsPartial")
+}

BTCPayServer/Views/Apps/UpdateCrowdfund.cshtml

@@ -1,4 +1,5 @@
 @addTagHelper *, BundlerMinifier.TagHelpers
+@using System.Globalization
 @model UpdateCrowdfundViewModel
 @{
     ViewData["Title"] = "Update Crowdfund";
@@ -67,7 +68,9 @@
                     <div class="form-group">
                         <label asp-for="StartDate" class="control-label"></label>
                         <div class="input-group ">
-                            <input asp-for="StartDate" class="form-control datetime"  placeholder="No start date has been set for this crowdfund"/>
+                            <input asp-for="StartDate"
+                                   value="@( Model.StartDate?.ToString("u", CultureInfo.InvariantCulture))"
+                                   class="datetime form-control" placeholder="No start date has been set for this crowdfund"/>
                             <div class="input-group-append">
 
                                 <button class="btn btn-secondary input-group-clear" type="button" title="Clear">
@@ -93,7 +96,11 @@
                     <div class="form-group">
                         <label asp-for="EndDate" class="control-label"></label>
                         <div class="input-group ">
-                            <input asp-for="EndDate" class="form-control datetime"  placeholder="No end date has been set for this crowdfund" />
+                            <input  type="datetime-local"  asp-for="EndDate"  
+                                    value="@( Model.EndDate?.ToString("u", CultureInfo.InvariantCulture))"
+                                   class="datetime form-control"   
+                                   type="datetime-local"  
+                                   placeholder="No end date has been set for this crowdfund" />
                             <div class="input-group-append">
 
                                 <button class="btn btn-secondary input-group-clear" type="button" title="Clear">
@@ -138,8 +145,13 @@
                         <span asp-validation-for="NotificationUrl" class="text-danger"></span>
                     </div>
                     <div class="form-group">
+                       
                         <label asp-for="NotificationEmail" class="control-label"></label>
-                        <input type="email" asp-for="NotificationEmail" class="form-control" />
+                        @if (Model.NotificationEmailWarning)
+                        {
+                            <partial name="NotificationEmailWarning"></partial>
+                        }
+                        <input type="email" asp-for="NotificationEmail" class="form-control"/>
                         <span asp-validation-for="NotificationEmail" class="text-danger"></span>
                     </div>
                     <div class="form-group">
@@ -199,6 +211,8 @@
                         <input asp-for="DisqusShortname" class="form-control" />
                         <span asp-validation-for="DisqusShortname" class="text-danger"></span>
                     </div>
+                    
+                    <input type="hidden" asp-for="NotificationEmailWarning"/>
                     <div class="form-group">
                         <input type="submit" class="btn btn-primary" value="Save Settings" />
                         <a class="btn btn-secondary" target="_blank" asp-action="ListInvoices" asp-controller="Invoice" asp-route-searchterm="@Model.SearchTerm">Invoices</a>
@@ -214,6 +228,7 @@
 
 @section Scripts {
 
+    <script src= "~/vendor/moment/moment.js"></script>
     <bundle name="wwwroot/bundles/crowdfund-admin-bundle.min.js"></bundle>
     <bundle name="wwwroot/bundles/crowdfund-admin-bundle.min.css"></bundle>
 

BTCPayServer/Views/Apps/UpdatePointOfSale.cshtml

@@ -115,7 +115,11 @@
                     </div>
                     <div class="form-group">
                         <label asp-for="NotificationEmail" class="control-label"></label>
-                        <input type="email" asp-for="NotificationEmail" class="form-control" />
+                        @if (Model.NotificationEmailWarning)
+                        {
+                            <partial name="NotificationEmailWarning"></partial>
+                        }
+                        <input type="email" asp-for="NotificationEmail" class="form-control"/>
                         <span asp-validation-for="NotificationEmail" class="text-danger"></span>
                     </div>
                     <div class="form-group">
@@ -123,6 +127,7 @@
                         <select asp-for="RedirectAutomatically" asp-items="Model.RedirectAutomaticallySelectList" class="form-control"></select>
                         <span asp-validation-for="RedirectAutomatically" class="text-danger"></span>
                     </div>
+                    <input type="hidden" asp-for="NotificationEmailWarning"/>
                     <div class="form-group">
                         <input type="submit" class="btn btn-primary" value="Save Settings" />
                     </div>

BTCPayServer/Views/AppsPublic/Crowdfund/VueCrowdfund.cshtml

@@ -12,10 +12,10 @@
                 <h1>
                     {{srvModel.title}} 
                     <span class="h6 text-muted" v-if="!started && srvModel.startDate" v-b-tooltip :title="startDate" id="crowdfund-header-start-date">
-                        Starts {{startDateRelativeTime}}
+                        Starts in {{startDiff}}
                     </span>
                     <span class="h6 text-muted" v-else-if="started && !ended && srvModel.endDate" v-b-tooltip :title="endDate" id="crowdfund-header-end-date">
-                        Ends {{endDateRelativeTime}}
+                        Ends in {{endDiff}}
                     </span>
                     <span class="h6 text-muted" v-else-if="started && !ended && !srvModel.endDate" v-b-tooltip title="No set end date" id="crowdfund-header-active">
                         Currently Active!
@@ -58,7 +58,7 @@
             </div>
            
             <div class="card-body">
-                <div class="row py-2 text-center">
+                <div class="row py-2 text-center crowdfund-stats">
                     <div class="col-sm border-right" id="crowdfund-body-raised-amount">
                         <h5>{{ raisedAmount }} {{targetCurrency}} </h5>
                         <h5 class="text-muted">Raised</h5>
@@ -73,23 +73,7 @@
                         </h5>
                         <h5 class="text-muted">Contributors</h5>
                     </div> 
-                    <div  class="col-sm" v-if="endDiff" id="crowdfund-body-campaign-dates-started">
-                        <h5>
-                            {{endDiff}}
-                        </h5>
-                        <h5 class="text-muted">Left</h5>
-                        <b-tooltip target="crowdfund-body-campaign-dates-started" >
-                            <ul class="p-0">
-                                <li v-if="startDate" class="list-unstyled">
-                                    {{started? "Started" : "Starts"}} {{startDate}}
-                                </li>
-                                <li v-if="endDate" class="list-unstyled">
-                                    {{ended? "Ended" : "Ends"}} {{endDate}}
-                                </li>
-                            </ul>
-                        </b-tooltip>
-                    </div>
-                    <div  class="col-sm" v-if="startDiff" id="crowdfund-body-campaign-dates-not-started">
+                    <div  class="col-sm  border-right" v-if="startDiff" id="crowdfund-body-campaign-dates-not-started">
                         <h5>
                             {{startDiff}}
                         </h5>
@@ -106,7 +90,23 @@
                             </ul>
                         </b-tooltip>
                     </div>
-                    <div  class="col-sm" v-if="ended" id="crowdfund-body-campaign-dates-not-active">
+                    <div  class="col-sm  border-right" v-if="endDiff" id="crowdfund-body-campaign-dates-started">
+                        <h5>
+                            {{endDiff}}
+                        </h5>
+                        <h5 class="text-muted">Left</h5>
+                        <b-tooltip target="crowdfund-body-campaign-dates-started" >
+                            <ul class="p-0">
+                                <li v-if="startDate" class="list-unstyled">
+                                    {{started? "Started" : "Starts"}} {{startDate}}
+                                </li>
+                                <li v-if="endDate" class="list-unstyled">
+                                    {{ended? "Ended" : "Ends"}} {{endDate}}
+                                </li>
+                            </ul>
+                        </b-tooltip>
+                    </div>
+                    <div  class="col-sm border-right" v-if="ended" id="crowdfund-body-campaign-dates-not-active">
                         <h5>
                             Campaign
                         </h5>