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

@@ -0,0 +1,102 @@
+version: 2
+jobs:
+  build:
+    machine: 
+      docker_layer_caching: true
+    steps: 
+      - checkout
+
+  test:
+    machine:
+        docker_layer_caching: true
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd BTCPayServer.Tests
+            docker-compose down --v
+            docker-compose build
+            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:
+    machine:
+      docker_layer_caching: true
+    steps:
+      - checkout  
+      - run:
+          command: |
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            #
+            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f Dockerfile.linuxamd64 .
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-amd64
+
+  publish_docker_linuxarm:
+    machine:
+      docker_layer_caching: true
+    steps:
+      - checkout  
+      - run:
+          command: |
+            sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            #
+            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f Dockerfile.linuxarm32v7 .
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
+
+  publish_docker_multiarch:
+    machine:
+      enabled: true
+      image: circleci/classic:201808-01
+    steps:
+      - run:
+          command: |
+            # Turn on Experimental features
+            sudo mkdir $HOME/.docker
+            sudo sh -c 'echo "{ \"experimental\": \"enabled\" }" >> $HOME/.docker/config.json'
+            #
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            #
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
+            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 --os linux --arch amd64
+            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 --os linux --arch arm --variant v7
+            sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG -p
+
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      - test
+
+  publish:
+    jobs:
+      - publish_docker_linuxamd64:
+          filters:
+            # ignore any commit on any branch by default
+            branches:
+              ignore: /.*/
+            # only act on version tags
+            tags:
+              only: /v[1-9]+(\.[0-9]+)*/
+      - publish_docker_linuxarm:
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /v[1-9]+(\.[0-9]+)*/
+      - publish_docker_multiarch:
+          requires:
+            - publish_docker_linuxamd64
+            - publish_docker_linuxarm
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /v[1-9]+(\.[0-9]+)*/

.dockerignore

@@ -1,6 +1,6 @@
 # Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
-[Bb]in/
-[Oo]bj/
+**/[Bb]in/
+**/[Oo]bj/
 node_modules/
 dist/
 
@@ -121,4 +121,4 @@ bower_components
 output
 
 .vs
-BTCPayServer.Tests/
+**/launchSettings.json

.editorconfig

@@ -0,0 +1,149 @@
+# editorconfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Default settings:
+# A newline ending every file
+# Use 4 spaces as indentation
+[*]
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+
+[project.json]
+indent_size = 2
+
+# C# files
+[*.cs]
+# New line preferences
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_within_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = flush_left
+
+# avoid this. unless absolutely necessary
+dotnet_style_qualification_for_field = false:suggestion
+dotnet_style_qualification_for_property = false:suggestion
+dotnet_style_qualification_for_method = false:suggestion
+dotnet_style_qualification_for_event = false:suggestion
+
+# only use var when it's obvious what the variable type is
+csharp_style_var_for_built_in_types = false:none
+csharp_style_var_when_type_is_apparent = false:none
+csharp_style_var_elsewhere = false:suggestion
+
+# use language keywords instead of BCL types
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+
+# name all constant fields using PascalCase
+dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields
+dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style
+
+dotnet_naming_symbols.constant_fields.applicable_kinds   = field
+dotnet_naming_symbols.constant_fields.required_modifiers = const
+
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+
+# internal and private fields should be _camelCase
+dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion
+dotnet_naming_rule.camel_case_for_private_internal_fields.symbols  = private_internal_fields
+dotnet_naming_rule.camel_case_for_private_internal_fields.style    = camel_case_underscore_style
+
+dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
+dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
+
+dotnet_naming_style.camel_case_underscore_style.required_prefix = _
+dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case 
+
+# Code style defaults
+dotnet_sort_system_directives_first = true
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = false
+
+# Expression-level preferences
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+
+# Expression-bodied members
+csharp_style_expression_bodied_methods = false:none
+csharp_style_expression_bodied_constructors = false:none
+csharp_style_expression_bodied_operators = false:none
+csharp_style_expression_bodied_properties = true:none
+csharp_style_expression_bodied_indexers = true:none
+csharp_style_expression_bodied_accessors = true:none
+
+# Pattern matching
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+
+# Null checking preferences
+csharp_style_throw_expression = true:suggestion
+csharp_style_conditional_delegate_call = true:suggestion
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = do_not_ignore
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# C++ Files
+[*.{cpp,h,in}]
+curly_bracket_next_line = true
+indent_brace_style = Allman
+
+# Xml project files
+[*.{csproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}]
+indent_size = 2
+
+# Xml build files
+[*.builds]
+indent_size = 2
+
+# Xml files
+[*.{xml,stylecop,resx,ruleset}]
+indent_size = 2
+
+# Xml config files
+[*.{props,targets,config,nuspec}]
+indent_size = 2
+
+# Shell scripts
+[*.sh]
+end_of_line = lf
+[*.{cmd, bat}]
+end_of_line = crlf

.gitattributes

@@ -0,0 +1,17 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.c text
+*.h text
+
+# Declare files that will always have CRLF line endings on checkout.
+*.sln text eol=crlf
+
+# Declare files that will always have CRLF line endings on checkout.
+*.sh text eol=lf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/feature_request.md

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

.gitignore

@@ -47,7 +47,6 @@ dlldata.c
 project.lock.json
 project.fragment.lock.json
 artifacts/
-**/Properties/launchSettings.json
 
 *_i.c
 *_p.c
@@ -288,3 +287,9 @@ __pycache__/
 *.odx.cs
 *.xsd.cs
 /BTCPayServer/Build/dockerfiles
+
+# Bundling JS/CSS
+BTCPayServer/wwwroot/bundles/*
+!BTCPayServer/wwwroot/bundles/.gitignore
+
+.vscode

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -1,16 +1,33 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
 
     <IsPackable>false</IsPackable>
+    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
+    <LangVersion>7.2</LangVersion>
+    <UserSecretsId>AB0AC1DD-9D26-485B-9416-56A33F268117</UserSecretsId>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170720-02" />
-    <PackageReference Include="NBitcoin.TestFramework" Version="1.4.4" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update=".dockerignore">
+      <DependentUpon>Dockerfile</DependentUpon>
+    </None>
+    <None Update="docker-compose.yml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="xunit.runner.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
   <ItemGroup>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -1,7 +1,14 @@
 using BTCPayServer.Configuration;
+using System.Linq;
+using BTCPayServer.HostedServices;
 using BTCPayServer.Hosting;
-using BTCPayServer.Servcices.Invoices;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Rating;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
 using BTCPayServer.Tests.Logging;
 using BTCPayServer.Tests.Mocks;
 using Microsoft.AspNetCore.Hosting;
@@ -13,7 +20,6 @@ using Microsoft.AspNetCore.Mvc.Routing;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
-using NBitcoin.Tests;
 using NBXplorer;
 using NBXplorer.DerivationStrategy;
 using System;
@@ -28,113 +34,245 @@ using System.Security.Principal;
 using System.Text;
 using System.Threading;
 using Xunit;
+using BTCPayServer.Services;
+using System.Net.Http;
 
 namespace BTCPayServer.Tests
 {
-	public class BTCPayServerTester : IDisposable
-	{
-		private string _Directory;
+    public enum TestDatabases
+    {
+        Postgres,
+        MySQL,
+    }
 
-		public BTCPayServerTester(string scope)
-		{
-			this._Directory = scope ?? throw new ArgumentNullException(nameof(scope));
-		}
+    public class BTCPayServerTester : IDisposable
+    {
+        private string _Directory;
 
-		public Uri NBXplorerUri
-		{
-			get; set;
-		}
-		public string CookieFile
-		{
-			get; set;
-		}
-		public Uri ServerUri
-		{
-			get;
-			set;
-		}
+        public BTCPayServerTester(string scope)
+        {
+            this._Directory = scope ?? throw new ArgumentNullException(nameof(scope));
+        }
 
-		public ExtKey HDPrivateKey
-		{
-			get; set;
-		}
+        public Uri NBXplorerUri
+        {
+            get; set;
+        }
 
-		IWebHost _Host;
-		public void Start()
-		{
-			if(!Directory.Exists(_Directory))
-				Directory.CreateDirectory(_Directory);
+        public Uri LTCNBXplorerUri { get; set; }
 
-			HDPrivateKey = new ExtKey();
-			var port = Utils.FreeTcpPort();
-			StringBuilder config = new StringBuilder();
-			config.AppendLine($"regtest=1");
-			config.AppendLine($"port={port}");
-			config.AppendLine($"explorer.url={NBXplorerUri.AbsoluteUri}");
-			config.AppendLine($"explorer.cookiefile={CookieFile}");
-			config.AppendLine($"hdpubkey={HDPrivateKey.Neuter().ToString(Network.RegTest)}");
-			File.WriteAllText(Path.Combine(_Directory, "settings.config"), config.ToString());
+        public Uri ServerUri
+        {
+            get;
+            set;
+        }
 
-			ServerUri = new Uri("http://127.0.0.1:" + port + "/");
+        public string MySQL
+        {
+            get; set;
+        }
 
-			var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory });
+        public string Postgres
+        {
+            get; set;
+        }
 
-			_Host = new WebHostBuilder()
-					.UseConfiguration(conf)
-					.ConfigureServices(s =>
-					{
-						s.AddSingleton<IRateProvider>(new MockRateProvider(new Rate("USD", 5000m)));
-						s.AddLogging(l =>
-						{
-							l.SetMinimumLevel(LogLevel.Information)
-							.AddFilter("Microsoft", LogLevel.Error)
-							.AddProvider(Logs.LogProvider);
-						});
-					})
-					.UseKestrel()
-					.UseStartup<Startup>()
-					.Build();
-			_Host.Start();
-			Runtime = (BTCPayServerRuntime)_Host.Services.GetService(typeof(BTCPayServerRuntime));
-			var watcher = (InvoiceWatcher)_Host.Services.GetService(typeof(InvoiceWatcher));
-			watcher.PollInterval = TimeSpan.FromMilliseconds(50);
-		}
+        IWebHost _Host;
+        public int Port
+        {
+            get; set;
+        }
 
-		public BTCPayServerRuntime Runtime
-		{
-			get; set;
-		}
+        public TestDatabases TestDatabase
+        {
+            get; set;
+        }
 
-		public T GetController<T>(string userId = null) where T : Controller
-		{
-			var context = new DefaultHttpContext();
-			context.Request.Host = new HostString("127.0.0.1");
-			context.Request.Scheme = "http";
-			context.Request.Protocol = "http";
-			if(userId != null)
-			{
-				context.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, userId) }));
-			}
-			var scope = (IServiceScopeFactory)_Host.Services.GetService(typeof(IServiceScopeFactory));
-			var provider = scope.CreateScope().ServiceProvider;
-			context.RequestServices = provider;
+        public bool MockRates { get; set; } = true;
 
-			var httpAccessor = provider.GetRequiredService<IHttpContextAccessor>();
-			httpAccessor.HttpContext = context;
+        public void Start()
+        {
+            if (!Directory.Exists(_Directory))
+                Directory.CreateDirectory(_Directory);
+            string chain = NBXplorerDefaultSettings.GetFolderName(NetworkType.Regtest);
+            string chainDirectory = Path.Combine(_Directory, chain);
+            if (!Directory.Exists(chainDirectory))
+                Directory.CreateDirectory(chainDirectory);
 
-			var controller = (T)ActivatorUtilities.CreateInstance(provider, typeof(T));
-			controller.Url = new UrlHelperMock();
-			controller.ControllerContext = new ControllerContext()
-			{
-				HttpContext = context
-			};
-			return controller;
-		}
 
-		public void Dispose()
-		{
-			if(_Host != null)
-				_Host.Dispose();
-		}
-	}
+            StringBuilder config = new StringBuilder();
+            config.AppendLine($"{chain.ToLowerInvariant()}=1");
+            config.AppendLine($"port={Port}");
+            config.AppendLine($"chains=btc,ltc");
+
+            config.AppendLine($"btc.explorer.url={NBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"btc.explorer.cookiefile=0");
+
+            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))
+                config.AppendLine($"mysql=" + MySQL);
+            else if (!String.IsNullOrEmpty(Postgres))
+                config.AppendLine($"postgres=" + Postgres);
+            var confPath = Path.Combine(chainDirectory, "settings.config");
+            File.WriteAllText(confPath, config.ToString());
+
+            ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
+            HttpClient = new HttpClient();
+            HttpClient.BaseAddress = ServerUri;
+            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
+            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath, "--disable-registration", "false" });
+            _Host = new WebHostBuilder()
+                    .UseConfiguration(conf)
+                    .UseContentRoot(FindBTCPayServerDirectory())
+                    .ConfigureServices(s =>
+                    {
+                        s.AddLogging(l =>
+                        {
+                            l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
+                            l.SetMinimumLevel(LogLevel.Information)
+                            .AddFilter("Microsoft", LogLevel.Error)
+                            .AddFilter("Hangfire", LogLevel.Error)
+                            .AddProvider(Logs.LogProvider);
+                        });
+                    })
+                    .UseKestrel()
+                    .UseStartup<Startup>()
+                    .Build();
+            _Host.Start();
+            InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
+            StoreRepository = (StoreRepository)_Host.Services.GetService(typeof(StoreRepository));
+            var dashBoard = (NBXplorerDashboard)_Host.Services.GetService(typeof(NBXplorerDashboard));
+            while(!dashBoard.IsFullySynched())
+            {
+                Thread.Sleep(10);
+            }
+
+            if (MockRates)
+            {
+                var rateProvider = (RateProviderFactory)_Host.Services.GetService(typeof(RateProviderFactory));
+                rateProvider.Providers.Clear();
+
+                var coinAverageMock = new MockRateProvider();
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("BTC_USD"),
+                    BidAsk = new BidAsk(5000m)
+                });
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("BTC_CAD"),
+                    BidAsk = new BidAsk(4500m)
+                });
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("LTC_BTC"),
+                    BidAsk = new BidAsk(0.001m)
+                });
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("LTC_USD"),
+                    BidAsk = new BidAsk(500m)
+                });
+                rateProvider.Providers.Add("coinaverage", coinAverageMock);
+
+                var bitflyerMock = new MockRateProvider();
+                bitflyerMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "bitflyer",
+                    CurrencyPair = CurrencyPair.Parse("BTC_JPY"),
+                    BidAsk = new BidAsk(700000m)
+                });
+                rateProvider.Providers.Add("bitflyer", bitflyerMock);
+
+                var quadrigacx = new MockRateProvider();
+                quadrigacx.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "quadrigacx",
+                    CurrencyPair = CurrencyPair.Parse("BTC_CAD"),
+                    BidAsk = new BidAsk(6000m)
+                });
+                rateProvider.Providers.Add("quadrigacx", quadrigacx);
+
+                var bittrex = new MockRateProvider();
+                bittrex.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "bittrex",
+                    CurrencyPair = CurrencyPair.Parse("DOGE_BTC"),
+                    BidAsk = new BidAsk(0.004m)
+                });
+                rateProvider.Providers.Add("bittrex", bittrex);
+            }
+        }
+
+        private string FindBTCPayServerDirectory()
+        {
+            var solutionDirectory = LanguageService.TryGetSolutionDirectoryInfo(Directory.GetCurrentDirectory());
+            return Path.Combine(solutionDirectory.FullName, "BTCPayServer");
+        }
+
+        public HttpClient HttpClient { get; set; }
+
+        public string HostName
+        {
+            get;
+            internal set;
+        }
+        public InvoiceRepository InvoiceRepository { get; private set; }
+        public StoreRepository StoreRepository { get; private set; }
+        public Uri IntegratedLightning { get; internal set; }
+        public bool InContainer { get; internal set; }
+
+        public T GetService<T>()
+        {
+            return _Host.Services.GetRequiredService<T>();
+        }
+
+        public T GetController<T>(string userId = null, string storeId = null, Claim[] additionalClaims = null) where T : Controller
+        {
+            var context = new DefaultHttpContext();
+            context.Request.Host = new HostString("127.0.0.1", Port);
+            context.Request.Scheme = "http";
+            context.Request.Protocol = "http";
+            if (userId != null)
+            {
+                List<Claim> claims = new List<Claim>();
+                claims.Add(new Claim(ClaimTypes.NameIdentifier, userId));
+                if (additionalClaims != null)
+                    claims.AddRange(additionalClaims);
+                context.User = new ClaimsPrincipal(new ClaimsIdentity(claims.ToArray(), Policies.CookieAuthentication));
+            }
+            if (storeId != null)
+            {
+                context.SetStoreData(GetService<StoreRepository>().FindStore(storeId, userId).GetAwaiter().GetResult());
+            }
+            var scope = (IServiceScopeFactory)_Host.Services.GetService(typeof(IServiceScopeFactory));
+            var provider = scope.CreateScope().ServiceProvider;
+            context.RequestServices = provider;
+
+            var httpAccessor = provider.GetRequiredService<IHttpContextAccessor>();
+            httpAccessor.HttpContext = context;
+
+            var controller = (T)ActivatorUtilities.CreateInstance(provider, typeof(T));
+
+            controller.Url = new UrlHelperMock(new Uri($"http://{HostName}:{Port}/"));
+            controller.ControllerContext = new ControllerContext()
+            {
+                HttpContext = context
+            };
+            return controller;
+        }
+
+        public void Dispose()
+        {
+            if (_Host != null)
+                _Host.Dispose();
+        }
+    }
 }

BTCPayServer.Tests/ChangellyTests.cs

@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Models;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Changelly.Models;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class ChangellyTests
+    {
+        public ChangellyTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanSetChangellyPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+
+                var storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.Null(storeBlob.ChangellySettings);
+
+                var updateModel = new UpdateChangellySettingsViewModel()
+                {
+                    ApiSecret = "secret",
+                    ApiKey = "key",
+                    ApiUrl = "http://gozo.com",
+                    ChangellyMerchantId = "aaa",
+                };
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+                storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.NotNull(storeBlob.ChangellySettings);
+                Assert.NotNull(storeBlob.ChangellySettings);
+                Assert.IsType<ChangellySettings>(storeBlob.ChangellySettings);
+                Assert.Equal(storeBlob.ChangellySettings.ApiKey, updateModel.ApiKey);
+                Assert.Equal(storeBlob.ChangellySettings.ApiSecret,
+                    updateModel.ApiSecret);
+                Assert.Equal(storeBlob.ChangellySettings.ApiUrl, updateModel.ApiUrl);
+                Assert.Equal(storeBlob.ChangellySettings.ChangellyMerchantId,
+                    updateModel.ChangellyMerchantId);
+            }
+        }
+
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanToggleChangellyPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                var updateModel = new UpdateChangellySettingsViewModel()
+                {
+                    ApiSecret = "secret",
+                    ApiKey = "key",
+                    ApiUrl = "http://gozo.com",
+                    ChangellyMerchantId = "aaa",
+                    Enabled = true
+                };
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.True(store.GetStoreBlob().ChangellySettings.Enabled);
+
+                updateModel.Enabled = false;
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.False(store.GetStoreBlob().ChangellySettings.Enabled);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CannotUseChangellyApiWithoutChangellyPaymentMethodSet()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var changellyController =
+                    tester.PayTester.GetController<ChangellyController>(user.UserId, user.StoreId);
+                changellyController.IsTest = true;
+
+                //test non existing payment method
+                Assert.IsType<BitpayErrorModel>(Assert
+                    .IsType<BadRequestObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value);
+
+                var updateModel = CreateDefaultChangellyParams(false);
+                var storesController = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+                //set payment method but disabled
+
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                Assert.IsType<BitpayErrorModel>(Assert
+                    .IsType<BadRequestObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value);
+
+                updateModel.Enabled = true;
+                //test with enabled method
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                Assert.IsNotType<BitpayErrorModel>(Assert
+                    .IsType<OkObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value);
+            }
+        }
+
+        UpdateChangellySettingsViewModel CreateDefaultChangellyParams(bool enabled)
+        {
+            return new UpdateChangellySettingsViewModel()
+            {
+                ApiKey = "6ed02cdf1b614d89a8c0ceb170eebb61",
+                ApiSecret = "8fbd66a2af5fd15a6b5f8ed0159c5842e32a18538521ffa145bd6c9e124d3483",
+                ChangellyMerchantId = "804298eb5753",
+                Enabled = enabled
+            };
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanGetCurrencyListFromChangelly()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+                //save changelly settings
+                var updateModel = CreateDefaultChangellyParams(true);
+                var storesController = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                //confirm saved
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var factory = UnitTest1.CreateBTCPayRateFactory();
+                var fetcher = new RateFetcher(factory);
+                var httpClientFactory = new MockHttpClientFactory();
+                var changellyController = new ChangellyController(
+                    new ChangellyClientProvider(tester.PayTester.StoreRepository, httpClientFactory),
+                    tester.NetworkProvider, fetcher);
+                changellyController.IsTest = true;
+                var result = Assert
+                    .IsType<OkObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value as IEnumerable<CurrencyFull>;
+                Assert.True(result.Any());
+            }
+        }
+
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanCalculateToAmountForChangelly()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+                var updateModel = CreateDefaultChangellyParams(true);
+                var storesController = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var factory = UnitTest1.CreateBTCPayRateFactory();
+                var fetcher = new RateFetcher(factory);
+                var httpClientFactory = new MockHttpClientFactory();
+                var changellyController = new ChangellyController(
+                    new ChangellyClientProvider(tester.PayTester.StoreRepository, httpClientFactory),
+                    tester.NetworkProvider, fetcher);
+                changellyController.IsTest = true;
+                Assert.IsType<decimal>(Assert
+                    .IsType<OkObjectResult>(await changellyController.CalculateAmount(user.StoreId, "ltc", "btc", 1.0m, default))
+                    .Value);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeBaseAmount()
+        {
+            Assert.Equal(1, ChangellyCalculationHelper.ComputeBaseAmount(1, 1));
+            Assert.Equal(0.5m, ChangellyCalculationHelper.ComputeBaseAmount(1, 0.5m));
+            Assert.Equal(2, ChangellyCalculationHelper.ComputeBaseAmount(0.5m, 1));
+            Assert.Equal(4m, ChangellyCalculationHelper.ComputeBaseAmount(1, 4));
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeCorrectAmount()
+        {
+            Assert.Equal(1, ChangellyCalculationHelper.ComputeCorrectAmount(0.5m, 1, 2));
+            Assert.Equal(0.25m, ChangellyCalculationHelper.ComputeCorrectAmount(0.5m, 1, 0.5m));
+            Assert.Equal(20, ChangellyCalculationHelper.ComputeCorrectAmount(10, 1, 2));
+        }
+    }
+
+    public class MockHttpClientFactory : IHttpClientFactory
+    {
+        public HttpClient CreateClient(string name)
+        {
+            return new HttpClient();
+        }
+    }
+}

BTCPayServer.Tests/ChargeTester.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Lightning;
+using BTCPayServer.Lightning.Charge;
+using BTCPayServer.Payments.Lightning;
+using NBitcoin;
+
+namespace BTCPayServer.Tests
+{
+    public class ChargeTester
+    {
+        private ServerTester _Parent;
+
+        public ChargeTester(ServerTester serverTester, string environmentName, string defaultValue, string defaultHost, Network network)
+        {
+            this._Parent = serverTester;
+            var url = serverTester.GetEnvironment(environmentName, defaultValue);
+            Client = (ChargeClient)LightningClientFactory.CreateClient(url, network);
+            P2PHost = _Parent.GetEnvironment(environmentName + "_HOST", defaultHost);
+        }        
+        public ChargeClient Client { get; set; }
+        public string P2PHost { get; }
+    }
+}

BTCPayServer.Tests/CoinSwitchTests.cs

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

BTCPayServer.Tests/CrowdfundTests.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Changelly.Models;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NBitcoin;
+using NBitpayClient;
+using Xunit;
+using Xunit.Abstractions;
+using static BTCPayServer.Tests.UnitTest1;
+
+namespace BTCPayServer.Tests
+{
+    public class CrowdfundTests
+    {
+        public CrowdfundTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanCreateAndDeleteCrowdfundApp()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var user2 = tester.NewAccount();
+                user2.GrantAccess();
+                var apps = user.GetController<AppsController>();
+                var apps2 = user2.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                Assert.NotNull(vm.SelectedAppType);
+                Assert.Null(vm.Name);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                Assert.Equal(nameof(apps.UpdateCrowdfund), redirectToAction.ActionName);
+                var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                var appList2 =
+                    Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps2.ListApps().Result).Model);
+                Assert.Single(appList.Apps);
+                Assert.Empty(appList2.Apps);
+                Assert.Equal("test", appList.Apps[0].AppName);
+                Assert.Equal(apps.CreatedAppId, appList.Apps[0].Id);
+                Assert.True(appList.Apps[0].IsOwner);
+                Assert.Equal(user.StoreId, appList.Apps[0].StoreId);
+                Assert.IsType<NotFoundResult>(apps2.DeleteApp(appList.Apps[0].Id).Result);
+                Assert.IsType<ViewResult>(apps.DeleteApp(appList.Apps[0].Id).Result);
+                redirectToAction = Assert.IsType<RedirectToActionResult>(apps.DeleteAppPost(appList.Apps[0].Id).Result);
+                Assert.Equal(nameof(apps.ListApps), redirectToAction.ActionName);
+                appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                Assert.Empty(appList.Apps);
+            }
+        }
+        
+        
+        
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanContributeOnlyWhenAllowed()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
+                    .Apps[0].Id;
+                
+                //Scenario 1: Not Enabled - Not Allowed
+                var crowdfundViewModel = Assert.IsType<UpdateCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(apps.UpdateCrowdfund(appId).Result).Model);
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.Enabled = false;
+                crowdfundViewModel.EndDate = null;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                
+                var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
+                var publicApps = user.GetController<AppsPublicController>();
+
+
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }, default));
+                
+                Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
+                
+                //Scenario 2: Not Enabled But Admin - Allowed
+                Assert.IsType<OkObjectResult>(await publicApps.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    RedirectToCheckout = false,
+                    Amount = new decimal(0.01)
+                }, default));
+                Assert.IsType<ViewResult>(await publicApps.ViewCrowdfund(appId, string.Empty));
+                Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
+                
+                //Scenario 3: Enabled But Start Date > Now - Not Allowed
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(2);
+                crowdfundViewModel.Enabled = true;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }, default));
+                
+                //Scenario 4: Enabled But End Date < Now - Not Allowed
+                
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(-2);
+                crowdfundViewModel.EndDate= DateTime.Today.AddDays(-1);
+                crowdfundViewModel.Enabled = true;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }, default));
+                
+                
+                //Scenario 5: Enabled and within correct timeframe, however target is enforced and Amount is Over - Not Allowed
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(-2);
+                crowdfundViewModel.EndDate= DateTime.Today.AddDays(2);
+                crowdfundViewModel.Enabled = true;
+                crowdfundViewModel.TargetAmount = 1;
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.EnforceTargetAmount = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(1.01)
+                }, default));
+                
+                //Scenario 6: Allowed
+                Assert.IsType<OkObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.05)
+                }, default));
+                
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeCrowdfundModel()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                user.ModifyStore(s => s.NetworkFeeMode = NetworkFeeMode.Never);
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
+                    .Apps[0].Id;
+
+                Logs.Tester.LogInformation("We create an invoice with a hardcap");
+                var crowdfundViewModel = Assert.IsType<UpdateCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(apps.UpdateCrowdfund(appId).Result).Model);
+                crowdfundViewModel.Enabled = true;
+                crowdfundViewModel.EndDate = null;
+                crowdfundViewModel.TargetAmount = 100;
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.UseAllStoreInvoices = true;
+                crowdfundViewModel.EnforceTargetAmount = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                
+                var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
+                var publicApps = user.GetController<AppsPublicController>();
+
+                var model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                
+                
+                Assert.Equal(crowdfundViewModel.TargetAmount, model.TargetAmount );
+                Assert.Equal(crowdfundViewModel.EndDate, model.EndDate );
+                Assert.Equal(crowdfundViewModel.StartDate, model.StartDate );
+                Assert.Equal(crowdfundViewModel.TargetCurrency, model.TargetCurrency );
+                Assert.Equal(0m, model.Info.CurrentAmount );
+                Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                Assert.Equal(0m, model.Info.ProgressPercentage);
+
+
+                Logs.Tester.LogInformation("Unpaid invoices should show as pending contribution because it is hardcap");
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is true, we can manually create an invoice and it should show as contribution");
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                
+                model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                
+                Assert.Equal(0m ,model.Info.CurrentAmount);
+                Assert.Equal(1m, model.Info.CurrentPendingAmount);
+                Assert.Equal(0m, model.Info.ProgressPercentage);
+                Assert.Equal(1m, model.Info.PendingProgressPercentage);
+
+                Logs.Tester.LogInformation("Let's check current amount change once payment is confirmed");
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, invoice.BtcDue);
+                tester.ExplorerNode.Generate(1); // By default invoice confirmed at 1 block
+                TestUtils.Eventually(() =>
+                {
+                    model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                    Assert.Equal(1m, model.Info.CurrentAmount);
+                    Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                });
+
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is true, let's make sure the invoice is tagged");
+                var invoiceEntity = tester.PayTester.InvoiceRepository.GetInvoice(invoice.Id).GetAwaiter().GetResult();
+                Assert.True(invoiceEntity.Version >= InvoiceEntity.InternalTagSupport_Version);
+                Assert.Contains(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
+
+                crowdfundViewModel.UseAllStoreInvoices = false;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is false, let's make sure the invoice is not tagged");
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                invoiceEntity = tester.PayTester.InvoiceRepository.GetInvoice(invoice.Id).GetAwaiter().GetResult();
+                Assert.DoesNotContain(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
+
+                Logs.Tester.LogInformation("After turning setting a softcap, let's check that only actual payments are counted");
+                crowdfundViewModel.EnforceTargetAmount = false;
+                crowdfundViewModel.UseAllStoreInvoices = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(0.5m));
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(0.2m));
+                TestUtils.Eventually(() =>
+                {
+                    model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                    Assert.Equal(0.7m, model.Info.CurrentPendingAmount);
+                });
+            }
+
+            
+        }
+        
+    }
+
+
+}

BTCPayServer.Tests/CustomerHttpServer.cs

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

BTCPayServer.Tests/Dockerfile

@@ -0,0 +1,14 @@
+FROM mcr.microsoft.com/dotnet/core/sdk:2.1.505-alpine3.7 AS builder
+ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT false
+RUN apk add --no-cache icu-libs
+ENV LC_ALL en_US.UTF-8
+ENV LANG en_US.UTF-8
+
+WORKDIR /source
+COPY BTCPayServer/BTCPayServer.csproj BTCPayServer/BTCPayServer.csproj
+COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj
+RUN dotnet restore BTCPayServer.Tests/BTCPayServer.Tests.csproj
+COPY . .
+RUN dotnet build
+WORKDIR /source/BTCPayServer.Tests
+ENTRYPOINT ["./docker-entrypoint.sh"]

BTCPayServer.Tests/LightningDTester.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Lightning.CLightning;
+using NBitcoin;
+
+namespace BTCPayServer.Tests
+{
+    public class LightningDTester
+    {
+        ServerTester parent;
+        public LightningDTester(ServerTester parent, string environmentName, string defaultRPC, string defaultHost, Network network)
+        {
+            this.parent = parent;
+            RPC = new CLightningClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), network);
+        }
+
+        public CLightningClient RPC { get; }
+        public string P2PHost { get; }
+        
+    }
+}

BTCPayServer.Tests/Lnd/LndMockTester.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Lightning.LND;
+using NBitcoin;
+
+namespace BTCPayServer.Tests.Lnd
+{
+    public class LndMockTester
+    {
+        private ServerTester _Parent;
+
+        public LndMockTester(ServerTester serverTester, string environmentName, string defaultValue, string defaultHost, Network network)
+        {
+            this._Parent = serverTester;
+            var url = serverTester.GetEnvironment(environmentName, defaultValue);
+
+            Swagger = new LndSwaggerClient(new LndRestSettings(new Uri(url)) { AllowInsecure = true });
+            Client = new LndClient(Swagger, network);
+            P2PHost = _Parent.GetEnvironment(environmentName + "_HOST", defaultHost);
+        }
+
+        public LndSwaggerClient Swagger { get; set; }
+        public LndClient Client { get; set; }
+        public string P2PHost { get; }
+    }
+}

BTCPayServer.Tests/Logging/Logs.cs

@@ -6,84 +6,88 @@ using Xunit.Abstractions;
 
 namespace BTCPayServer.Tests.Logging
 {
-	public interface ILog
-	{
-		void LogInformation(string msg);
-	}
+    public interface ILog
+    {
+        void LogInformation(string msg);
+    }
 
-	public class XUnitLogProvider : ILoggerProvider
-	{
-		ITestOutputHelper _Helper;
-		public XUnitLogProvider(ITestOutputHelper helper)
-		{
-			_Helper = helper;
-		}
-		public ILogger CreateLogger(string categoryName)
-		{
-			return new XUnitLog(_Helper) { Name = categoryName };
-		}
+    public class XUnitLogProvider : ILoggerProvider
+    {
+        ITestOutputHelper _Helper;
+        public XUnitLogProvider(ITestOutputHelper helper)
+        {
+            _Helper = helper;
+        }
+        public ILogger CreateLogger(string categoryName)
+        {
+            return new XUnitLog(_Helper) { Name = categoryName };
+        }
 
-		public void Dispose()
-		{
-			
-		}
-	}
-	public class XUnitLog : ILog, ILogger, IDisposable
-	{
-		ITestOutputHelper _Helper;
-		public XUnitLog(ITestOutputHelper helper)
-		{
-			_Helper = helper;
-		}
+        public void Dispose()
+        {
 
-		public string Name
-		{
-			get; set;
-		}
+        }
+    }
+    public class XUnitLog : ILog, ILogger, IDisposable
+    {
+        ITestOutputHelper _Helper;
+        public XUnitLog(ITestOutputHelper helper)
+        {
+            _Helper = helper;
+        }
 
-		public IDisposable BeginScope<TState>(TState state)
-		{
-			return this;
-		}
+        public string Name
+        {
+            get; set;
+        }
 
-		public void Dispose()
-		{
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            return this;
+        }
 
-		}
+        public void Dispose()
+        {
 
-		public bool IsEnabled(LogLevel logLevel)
-		{
-			return true;
-		}
+        }
 
-		public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
-		{
-			StringBuilder builder = new StringBuilder();
-			builder.Append(formatter(state, exception));
-			if(exception != null)
-			{
-				builder.AppendLine();
-				builder.Append(exception.ToString());
-			}
-			LogInformation(builder.ToString());
-		}
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            return true;
+        }
 
-		public void LogInformation(string msg)
-		{
-			if(msg != null)
-				_Helper.WriteLine(Name + ":   " + msg);
-		}
-	}
-	public class Logs
-	{
-		public static ILog Tester
-		{
-			get; set;
-		}
-		public static XUnitLogProvider LogProvider
-		{
-			get;
-			set;
-		}
-	}
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.Append(formatter(state, exception));
+            if (exception != null)
+            {
+                builder.AppendLine();
+                builder.Append(exception.ToString());
+            }
+            LogInformation(builder.ToString());
+        }
+
+        public void LogInformation(string msg)
+        {
+            if (msg != null)
+                try
+                {
+                    _Helper.WriteLine(DateTimeOffset.UtcNow + " :" + Name + ":   " + msg);
+                }
+                catch { }
+        }
+    }
+    public class Logs
+    {
+        public static ILog Tester
+        {
+            get; set;
+        }
+        public static XUnitLogProvider LogProvider
+        {
+            get;
+            set;
+        }
+    }
 }

BTCPayServer.Tests/MockDelay.cs

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

BTCPayServer.Tests/Mocks/MockRateProvider.cs

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

BTCPayServer.Tests/Mocks/UrlHelperMock.cs

@@ -6,33 +6,38 @@ using Microsoft.AspNetCore.Mvc.Routing;
 
 namespace BTCPayServer.Tests.Mocks
 {
-	public class UrlHelperMock : IUrlHelper
-	{
-		public ActionContext ActionContext => throw new NotImplementedException();
+    public class UrlHelperMock : IUrlHelper
+    {
+        Uri _BaseUrl;
+        public UrlHelperMock(Uri baseUrl)
+        {
+            _BaseUrl = baseUrl;
+        }
+        public ActionContext ActionContext => throw new NotImplementedException();
 
-		public string Action(UrlActionContext actionContext)
-		{
-			return "http://127.0.0.1/mock";
-		}
+        public string Action(UrlActionContext actionContext)
+        {
+            return $"{_BaseUrl}mock";
+        }
 
-		public string Content(string contentPath)
-		{
-			return "http://127.0.0.1/mock";
-		}
+        public string Content(string contentPath)
+        {
+            return $"{_BaseUrl}{contentPath}";
+        }
 
-		public bool IsLocalUrl(string url)
-		{
-			return false;
-		}
+        public bool IsLocalUrl(string url)
+        {
+            return false;
+        }
 
-		public string Link(string routeName, object values)
-		{
-			return "http://127.0.0.1/mock";
-		}
+        public string Link(string routeName, object values)
+        {
+            return _BaseUrl.AbsoluteUri;
+        }
 
-		public string RouteUrl(UrlRouteContext routeContext)
-		{
-			return "http://127.0.0.1/mock";
-		}
-	}
+        public string RouteUrl(UrlRouteContext routeContext)
+        {
+            return _BaseUrl.AbsoluteUri;
+        }
+    }
 }

BTCPayServer.Tests/NBXplorerTester.cs

@@ -1,112 +0,0 @@
-using NBitcoin;
-using NBitcoin.Tests;
-using NBXplorer.DerivationStrategy;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Net;
-using System.Net.Sockets;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading;
-using Xunit;
-
-namespace BTCPayServer.Tests
-{
-	public class NBXplorerTester : IDisposable
-	{
-		private string _Directory;
-
-		public NBXplorerTester(string scope)
-		{
-			if(scope == null)
-				throw new ArgumentNullException(nameof(scope));
-			this._Directory = scope;
-		}
-
-		Process _Process;
-
-		public CoreNode Node
-		{
-			get; set;
-		}
-
-		public void Start()
-		{
-			ProcessLauncher launcher = new ProcessLauncher();
-			launcher.GoTo("Repositories", true);
-			if(!launcher.GoTo(new[] { "nxbplorer", "NBXplorer" }))
-			{
-				launcher.Run("git", "clone https://github.com/dgarage/NBXplorer nxbplorer");
-				Assert.True(launcher.GoTo(new[] { "nxbplorer", "NBXplorer" }), "Could not clone nxbplorer");
-			}
-			launcher.PushDirectory();
-			if(!launcher.GoTo(new[] { "bin", "Release", "netcoreapp2.0" }) || !launcher.Exists("NBXplorer.dll"))
-			{
-				launcher.PopDirectory();
-				launcher.Run("git", "pull");
-				launcher.Run("git", "checkout master");
-				try
-				{
-					//Need to do that or VS insist in adding this repo as submodules :/
-					Utils.DeleteDirectory(Path.GetFullPath(Path.Combine(launcher.CurrentDirectory, "..", ".git")));
-				}
-				catch { }
-
-				launcher.Run("dotnet", "build /p:Configuration=Release");
-				Assert.True(launcher.GoTo(new[] { "bin", "Release", "netcoreapp2.0" }), "Could not build NBXplorer");
-
-				launcher.AssertExists("NBXplorer.dll");
-			}
-
-			var port = Utils.FreeTcpPort();
-			var launcher2 = new ProcessLauncher();
-			launcher2.GoTo(_Directory, true);
-			launcher2.GoTo("nbxplorer-datadir", true);
-			StringBuilder config = new StringBuilder();
-			config.AppendLine($"regtest=1");
-			config.AppendLine($"port={port}");
-			config.AppendLine($"rpc.url={Node.RPCUri.AbsoluteUri}");
-			config.AppendLine($"rpc.auth={Node.AuthenticationString}");
-			config.AppendLine($"node.endpoint={Node.NodeEndpoint.Address}:{Node.NodeEndpoint.Port}");
-			File.WriteAllText(Path.Combine(launcher2.CurrentDirectory, "settings.config"), config.ToString());
-			_Process = launcher.Start("dotnet", $"NBXplorer.dll --datadir \"{launcher2.CurrentDirectory}\"");
-			ExplorerClient = new NBXplorer.ExplorerClient(Node.Network, new Uri($"http://127.0.0.1:{port}/"));
-			CookieFile = Path.Combine(launcher2.CurrentDirectory, ".cookie");
-			File.Create(CookieFile).Close(); //Will be wipedout when the client starts
-			ExplorerClient.SetCookieAuth(CookieFile);
-			try
-			{
-				var cancellationSource = new CancellationTokenSource(10000);
-				ExplorerClient.WaitServerStarted(cancellationSource.Token);
-			}
-			catch(OperationCanceledException)
-			{
-				Assert.False(_Process.HasExited, "NBXplorer failed to launch");
-				throw;
-			}
-		}
-
-		public NBXplorer.ExplorerClient ExplorerClient
-		{
-			get; set;
-		}
-		public string CookieFile
-		{
-			get;
-			set;
-		}
-
-		public static NBXplorerTester Create([CallerMemberNameAttribute] string scope = null)
-		{
-			return new NBXplorerTester(scope);
-		}
-
-		public void Dispose()
-		{
-			if(_Process != null && !_Process.HasExited)
-				_Process.Kill();
-		}
-	}
-}

BTCPayServer.Tests/PaymentRequestTests.cs

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

@@ -8,105 +8,105 @@ using Xunit;
 
 namespace BTCPayServer.Tests
 {
-	public class ProcessLauncher
-	{
-		string _CurrentDirectory;
-		public string CurrentDirectory
-		{
-			get
-			{
-				return _CurrentDirectory;
-			}
-		}
-		public ProcessLauncher()
-		{
-			_CurrentDirectory = Directory.GetCurrentDirectory();
-		}
-		public bool GoTo(string[] directories, bool createIfNotExists = false)
-		{
-			var original = _CurrentDirectory;
-			foreach(var dir in directories)
-			{
-				var newDirectory = Path.Combine(_CurrentDirectory, dir);
-				if(!Directory.Exists(newDirectory))
-				{
-					if(createIfNotExists)
-						Directory.CreateDirectory(newDirectory);
-					else
-					{
-						_CurrentDirectory = original;
-						return false;
-					}
-				}
-				_CurrentDirectory = newDirectory;
-			}
-			return true;
-		}
+    public class ProcessLauncher
+    {
+        string _CurrentDirectory;
+        public string CurrentDirectory
+        {
+            get
+            {
+                return _CurrentDirectory;
+            }
+        }
+        public ProcessLauncher()
+        {
+            _CurrentDirectory = Directory.GetCurrentDirectory();
+        }
+        public bool GoTo(string[] directories, bool createIfNotExists = false)
+        {
+            var original = _CurrentDirectory;
+            foreach (var dir in directories)
+            {
+                var newDirectory = Path.Combine(_CurrentDirectory, dir);
+                if (!Directory.Exists(newDirectory))
+                {
+                    if (createIfNotExists)
+                        Directory.CreateDirectory(newDirectory);
+                    else
+                    {
+                        _CurrentDirectory = original;
+                        return false;
+                    }
+                }
+                _CurrentDirectory = newDirectory;
+            }
+            return true;
+        }
 
-		Stack<string> _Directories = new Stack<string>();
-		public void PushDirectory()
-		{
-			_Directories.Push(_CurrentDirectory);
-		}
+        Stack<string> _Directories = new Stack<string>();
+        public void PushDirectory()
+        {
+            _Directories.Push(_CurrentDirectory);
+        }
 
-		public void PopDirectory()
-		{
-			_CurrentDirectory = _Directories.Pop();
-		}
+        public void PopDirectory()
+        {
+            _CurrentDirectory = _Directories.Pop();
+        }
 
-		public bool GoTo(string directory, bool createIfNotExists = false)
-		{
-			return GoTo(new[] { directory }, createIfNotExists);
-		}
+        public bool GoTo(string directory, bool createIfNotExists = false)
+        {
+            return GoTo(new[] { directory }, createIfNotExists);
+        }
 
-		public void Run(string processName, string args)
-		{
-			Start(processName, args).WaitForExit();
-		}
+        public void Run(string processName, string args)
+        {
+            Start(processName, args).WaitForExit();
+        }
 
-		public Process Start(string processName, string args)
-		{
-			Logs.Tester.LogInformation($"Running [{processName} {args}] from {_CurrentDirectory}");
-			StringBuilder builder = new StringBuilder();
-			var process = new Process()
-			{
-				StartInfo = new ProcessStartInfo
-				{
-					WorkingDirectory = _CurrentDirectory,
-					FileName = processName,
-					Arguments = args,
-					RedirectStandardOutput = true,
-					RedirectStandardError = true
-				}
-			};
-			try
-			{
-				process.OutputDataReceived += (s, e) =>
-				{
-					Logs.Tester.LogInformation(e.Data);
-				};
-				process.ErrorDataReceived += (s, e) =>
-				{
-					Logs.Tester.LogInformation(e.Data);
-				};
-				process.Start();
-				process.BeginErrorReadLine();
-				process.BeginOutputReadLine();
-			}
-			catch(Exception ex) { throw new Exception($"You need to install {processName} for this test (info : {ex.Message})"); }
-			return process;
-		}
+        public Process Start(string processName, string args)
+        {
+            Logs.Tester.LogInformation($"Running [{processName} {args}] from {_CurrentDirectory}");
+            StringBuilder builder = new StringBuilder();
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    WorkingDirectory = _CurrentDirectory,
+                    FileName = processName,
+                    Arguments = args,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true
+                }
+            };
+            try
+            {
+                process.OutputDataReceived += (s, e) =>
+                {
+                    Logs.Tester.LogInformation(e.Data);
+                };
+                process.ErrorDataReceived += (s, e) =>
+                {
+                    Logs.Tester.LogInformation(e.Data);
+                };
+                process.Start();
+                process.BeginErrorReadLine();
+                process.BeginOutputReadLine();
+            }
+            catch (Exception ex) { throw new Exception($"You need to install {processName} for this test (info : {ex.Message})"); }
+            return process;
+        }
 
-		public void AssertExists(string file)
-		{
-			var path = Path.Combine(_CurrentDirectory, file);
-			Assert.True(File.Exists(path), $"The file {path} should exist");
-		}
+        public void AssertExists(string file)
+        {
+            var path = Path.Combine(_CurrentDirectory, file);
+            Assert.True(File.Exists(path), $"The file {path} should exist");
+        }
 
-		public bool Exists(string file)
-		{
-			var path = Path.Combine(_CurrentDirectory, file);
-			return File.Exists(path);
-		}
-	}
+        public bool Exists(string file)
+        {
+            var path = Path.Combine(_CurrentDirectory, file);
+            return File.Exists(path);
+        }
+    }
 }

BTCPayServer.Tests/Properties/launchSettings.json

@@ -0,0 +1,7 @@
+{
+    "profiles": {
+        "BTCPayServer.Tests": {
+            "commandName": "Project"
+        }
+    }
+}

BTCPayServer.Tests/README.md

@@ -0,0 +1,85 @@
+# How to be started for development
+
+BTCPay Server tests depend on having a proper environment running with Postgres, Bitcoind, NBxplorer configured.
+You can however use the `docker-compose.yml` of this folder to get it running.
+
+In addition, when you run a debug session of BTCPay (Hitting F5 on Visual Studio Code or Visual Studio 2017), it will run the launch profile called `Docker-Regtest`. This launch profile depends on this `docker-compose` running.
+
+This is running a bitcoind instance on regtest, a private bitcoin blockchain for testing on which you can generate blocks yourself.
+
+```
+docker-compose up dev
+```
+
+You can run the tests while it is running through your favorite IDE, or with
+
+```
+dotnet test
+```
+
+Once you want to stop
+
+```
+docker-compose down
+```
+
+If you want to stop, and remove all existing data
+
+```
+docker-compose down --v
+```
+
+You can run tests on `MySql` database instead of `Postgres` by setting environnement variable `TESTS_DB` equals to `MySql`.
+
+## How to manually test payments
+
+### Using the test bitcoin-cli
+
+You can call bitcoin-cli inside the container with `docker exec`, for example, if you want to send `0.23111090` to `mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf`:
+```
+./docker-bitcoin-cli.sh sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
+```
+
+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. 
+
+### Using the test lightning-cli
+
+If you are using Linux:
+```
+./docker-customer-lightning-cli.sh pay lnbcrt100u1pd2e6uspp5ajnadvhazjrz55twd5k6yeg9u87wpw0q2fdr7g960yl5asv5fmnqdq9d3hkccqpxmedyrk0ehw5ueqx5e0r4qrrv74cewddfcvsxaawqz7634cmjj39sqwy5tvhz0hasktkk6t9pqfdh3edmf3z09zst5y7khv3rvxh8ctqqw6mwhh
+```
+
+If you are using Powershell:
+```
+.\docker-customer-lightning-cli.ps1 pay lnbcrt100u1pd2e6uspp5ajnadvhazjrz55twd5k6yeg9u87wpw0q2fdr7g960yl5asv5fmnqdq9d3hkccqpxmedyrk0ehw5ueqx5e0r4qrrv74cewddfcvsxaawqz7634cmjj39sqwy5tvhz0hasktkk6t9pqfdh3edmf3z09zst5y7khv3rvxh8ctqqw6mwhh
+```
+
+If you get this message:
+
+```
+{ "code" : 205, "message" : "Could not find a route", "data" : { "getroute_tries" : 1, "sendpay_tries" : 0 } }
+```
+
+Please, run the test `CanSetLightningServer`, this will establish a channel between the customer and the merchant, then, retry.
+
+## FAQ
+
+`docker-compose up dev` failed or tests are not passing, what should I do?
+
+1. Run `docker-compose down --v` (this will reset your test environment)
+2. Run `docker-compose pull` (this will ensure you have the lastest images)
+3. Run again with `docker-compose up dev`
+
+If you still have issues, try to restart docker.

BTCPayServer.Tests/RateRulesTest.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Rating;
+using Xunit;
+using System.Globalization;
+
+namespace BTCPayServer.Tests
+{
+    public class RateRulesTest
+    {
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void SecondDuplicatedRuleIsIgnored()
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = 1.1");
+            builder.AppendLine("DOGE_X = 1.2");
+            Assert.True(RateRules.TryParse(builder.ToString(), out var rules));
+            var rule = rules.GetRuleFor(new CurrencyPair("DOGE", "BTC"));
+            rule.Reevaluate();
+            Assert.True(!rule.HasError);
+            Assert.Equal(1.1m, rule.BidAsk.Ask);
+        }
+
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void CanParseRateRules()
+        {
+            // Check happy path
+            StringBuilder builder = new StringBuilder();
+            builder.AppendLine("// Some cool comments");
+            builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X * 1.1");
+            builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
+            builder.AppendLine("// Some other cool comments");
+            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_X = Coinbase(BTC_X);");
+            builder.AppendLine("X_X = CoinAverage(X_X) * 1.02");
+
+            Assert.False(RateRules.TryParse("DPW*&W&#hdi&#&3JJD", out var rules));
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            Assert.Equal(
+                "// Some cool comments\n" +
+                "DOGE_X = DOGE_BTC * BTC_X * 1.1;\n" +
+                "DOGE_BTC = bittrex(DOGE_BTC);\n" +
+                "// Some other cool comments\n" +
+                "BTC_USD = gdax(BTC_USD);\n" +
+                "BTC_X = coinbase(BTC_X);\n" +
+                "X_X = coinaverage(X_X) * 1.02;",
+                rules.ToString());
+            var tests = new[]
+            {
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1"),
+                (Pair: "BTC_USD", Expected: "gdax(BTC_USD)"),
+                (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)"),
+                (Pair: "DOGE_CAD", Expected: "bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1"),
+                (Pair: "LTC_CAD", Expected: "coinaverage(LTC_CAD) * 1.02"),
+            };
+            foreach (var test in tests)
+            {
+                Assert.Equal(test.Expected, rules.GetRuleFor(CurrencyPair.Parse(test.Pair)).ToString());
+            }
+            rules.Spread = 0.2m;
+            Assert.Equal("(bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1) * (0.8, 1.2)", rules.GetRuleFor(CurrencyPair.Parse("DOGE_USD")).ToString());
+            ////////////////
+
+            // Check errors conditions
+            builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = LTC_CAD * BTC_X * 1.1");
+            builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
+            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("LTC_CHF = LTC_CHF * 1.01");
+            builder.AppendLine("BTC_X = Coinbase(BTC_X)");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+
+            tests = new[]
+            {
+                (Pair: "LTC_CAD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD)"),
+                (Pair: "DOGE_USD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD) * gdax(BTC_USD) * 1.1"),
+                (Pair: "LTC_CHF", Expected: "ERR_TOO_MUCH_NESTED_CALLS(LTC_CHF) * 1.01"),
+            };
+            foreach (var test in tests)
+            {
+                Assert.Equal(test.Expected, rules.GetRuleFor(CurrencyPair.Parse(test.Pair)).ToString());
+            }
+            //////////////////
+
+            // Check if we can resolve exchange rates
+            builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X * 1.1");
+            builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
+            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_X = Coinbase(BTC_X)");
+            builder.AppendLine("X_X = CoinAverage(X_X) * 1.02");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+
+            var tests2 = new[]
+            {
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),gdax(BTC_USD)"),
+                (Pair: "BTC_USD", Expected: "gdax(BTC_USD)", ExpectedExchangeRates: "gdax(BTC_USD)"),
+                (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)", ExpectedExchangeRates: "coinbase(BTC_CAD)"),
+                (Pair: "DOGE_CAD", Expected: "bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),coinbase(BTC_CAD)"),
+                (Pair: "LTC_CAD", Expected: "coinaverage(LTC_CAD) * 1.02", ExpectedExchangeRates: "coinaverage(LTC_CAD)"),
+            };
+            foreach (var test in tests2)
+            {
+                var rule = rules.GetRuleFor(CurrencyPair.Parse(test.Pair));
+                Assert.Equal(test.Expected, rule.ToString());
+                Assert.Equal(test.ExpectedExchangeRates, string.Join(',', rule.ExchangeRates.OfType<object>().ToArray()));
+            }
+            var rule2 = rules.GetRuleFor(CurrencyPair.Parse("DOGE_CAD"));
+            rule2.ExchangeRates.SetRate("bittrex", CurrencyPair.Parse("DOGE_BTC"), new BidAsk(5000m));
+            rule2.Reevaluate();
+            Assert.True(rule2.HasError);
+            Assert.Equal("5000 * ERR_RATE_UNAVAILABLE(coinbase, BTC_CAD) * 1.1", rule2.ToString(true));
+            Assert.Equal("bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1", rule2.ToString(false));
+            rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_CAD"), new BidAsk(2000.4m));
+            rule2.Reevaluate();
+            Assert.False(rule2.HasError);
+            Assert.Equal("5000 * 2000.4 * 1.1", rule2.ToString(true));
+            Assert.Equal(rule2.BidAsk.Bid, 5000m * 2000.4m * 1.1m);
+            ////////
+
+            // Make sure parenthesis are correctly calculated
+            builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X");
+            builder.AppendLine("BTC_USD = -3 + coinbase(BTC_CAD) + 50 - 5");
+            builder.AppendLine("DOGE_BTC = 2000");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rules.Spread = 0.1m;
+
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("DOGE_USD"));
+            Assert.Equal("(2000 * (-3 + coinbase(BTC_CAD) + 50 - 5)) * (0.9, 1.1)", rule2.ToString());
+            rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_CAD"), new BidAsk(1000m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("(2000 * (-3 + 1000 + 50 - 5)) * (0.9, 1.1)", rule2.ToString(true));
+            Assert.Equal((2000m * (-3m + 1000m + 50m - 5m)) * 0.9m, rule2.BidAsk.Bid);
+
+            // Test inverse
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_DOGE"));
+            Assert.Equal("(1 / (2000 * (-3 + coinbase(BTC_CAD) + 50 - 5))) * (0.9, 1.1)", rule2.ToString());
+            rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_CAD"), new BidAsk(1000m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("(1 / (2000 * (-3 + 1000 + 50 - 5))) * (0.9, 1.1)", rule2.ToString(true));
+            Assert.Equal((1.0m / (2000m * (-3m + 1000m + 50m - 5m))) * 0.9m, rule2.BidAsk.Bid);
+            ////////
+
+            // Make sure kraken is not converted to CurrencyPair
+            builder = new StringBuilder();
+            builder.AppendLine("BTC_USD = kraken(BTC_USD)");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("BTC_USD"));
+            rule2.ExchangeRates.SetRate("kraken", CurrencyPair.Parse("BTC_USD"), new BidAsk(1000m));
+            Assert.True(rule2.Reevaluate());
+
+            // Make sure can handle pairs
+            builder = new StringBuilder();
+            builder.AppendLine("BTC_USD = kraken(BTC_USD)");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("BTC_USD"));
+            rule2.ExchangeRates.SetRate("kraken", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("(6000, 6100)", rule2.ToString(true));
+            Assert.Equal(6000m, rule2.BidAsk.Bid);
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_BTC"));
+            rule2.ExchangeRates.SetRate("kraken", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("1 / (6000, 6100)", rule2.ToString(true));
+            Assert.Equal(1m / 6100m, rule2.BidAsk.Bid);
+
+            // Make sure the inverse has more priority than X_X or CDNT_X
+            builder = new StringBuilder();
+            builder.AppendLine("EUR_CDNT = 10");
+            builder.AppendLine("CDNT_BTC = CDNT_EUR * EUR_BTC;");
+            builder.AppendLine("CDNT_X = CDNT_BTC * BTC_X;");
+            builder.AppendLine("X_X = coinaverage(X_X);");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("CDNT_EUR"));
+            rule2.ExchangeRates.SetRate("coinaverage", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("1 / 10", rule2.ToString(false));
+
+            // Make sure an inverse can be solved on an exchange
+            builder = new StringBuilder();
+            builder.AppendLine("X_X = coinaverage(X_X);");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_BTC"));
+            rule2.ExchangeRates.SetRate("coinaverage", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal($"({(1m / 6100m).ToString(CultureInfo.InvariantCulture)}, {(1m / 6000m).ToString(CultureInfo.InvariantCulture)})", rule2.ToString(true));
+        }
+    }
+}

BTCPayServer.Tests/ServerTester.cs

@@ -1,89 +1,173 @@
 using BTCPayServer.Controllers;
+using System.Linq;
 using BTCPayServer.Models.AccountViewModels;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin;
-using NBitcoin.Tests;
+using NBitcoin.RPC;
 using NBitpayClient;
+using NBXplorer;
+using NBXplorer.Models;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.Net.Http;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
+using System.Threading;
+using System.Globalization;
+using BTCPayServer.Tests.Lnd;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Lightning.CLightning;
+using BTCPayServer.Lightning;
+using BTCPayServer.Services;
+using BTCPayServer.Tests.Logging;
 
 namespace BTCPayServer.Tests
 {
-	public class ServerTester : IDisposable
-	{
-		public static ServerTester Create([CallerMemberNameAttribute]string scope = null)
-		{
-			return new ServerTester(scope);
-		}
+    public class ServerTester : IDisposable
+    {
+        public static ServerTester Create([CallerMemberNameAttribute]string scope = null)
+        {
+            return new ServerTester(scope);
+        }
 
-		string _Directory;
-		NodeBuilder _Builder;
+        string _Directory;
+        public ServerTester(string scope)
+        {
+            _Directory = scope;
+            if (Directory.Exists(_Directory))
+                Utils.DeleteDirectory(_Directory);
+            if (!Directory.Exists(_Directory))
+                Directory.CreateDirectory(_Directory);
 
-		public ServerTester(string scope)
-		{
-			_Directory = scope;
-		}
+            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);
 
-		public void Start()
-		{
-			if(Directory.Exists(_Directory))
-				Utils.DeleteDirectory(_Directory);
-			if(!Directory.Exists(_Directory))
-				Directory.CreateDirectory(_Directory);
-			_Builder = NodeBuilder.Create(_Directory, "0.14.2");
-			ExplorerNode = _Builder.CreateNode(false);
-			ExplorerNode.WhiteBind = true;
-			ExplorerNode.Start();
-			ExplorerNode.CreateRPCClient().Generate(101);
-			ExplorerTester = NBXplorerTester.Create(Path.Combine(_Directory, "explorer"));
-			ExplorerTester.Node = ExplorerNode;
-			ExplorerTester.Start();
+            ExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("BTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_BTCNBXPLORERURL", "http://127.0.0.1:32838/")));
+            LTCExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("LTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_LTCNBXPLORERURL", "http://127.0.0.1:32838/")));
 
-			PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
-			{
-				NBXplorerUri = ExplorerTester.ExplorerClient.Address,
-				CookieFile = ExplorerTester.CookieFile
-			};
-			PayTester.Start();
-		}
+            var btc = NetworkProvider.GetNetwork("BTC").NBitcoinNetwork;
+            CustomerLightningD = LightningClientFactory.CreateClient(GetEnvironment("TEST_CUSTOMERLIGHTNINGD", "type=clightning;server=tcp://127.0.0.1:30992/"), btc);
+            MerchantLightningD = LightningClientFactory.CreateClient(GetEnvironment("TEST_MERCHANTLIGHTNINGD", "type=clightning;server=tcp://127.0.0.1:30993/"), btc);
 
-		public TestAccount CreateAccount()
-		{
-			return new TestAccount(this);
-		}
+            MerchantCharge = new ChargeTester(this, "TEST_MERCHANTCHARGE", "type=charge;server=http://127.0.0.1:54938/;api-token=foiewnccewuify", "merchant_lightningd", btc);
 
-		public CoreNode ExplorerNode
-		{
-			get; set;
-		}
+            MerchantLnd = new LndMockTester(this, "TEST_MERCHANTLND", "https://lnd:lnd@127.0.0.1:53280/", "merchant_lnd", btc);
 
-		public BTCPayServerTester PayTester
-		{
-			get; set;
-		}
+            PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
+            {
+                NBXplorerUri = ExplorerClient.Address,
+                LTCNBXplorerUri = LTCExplorerClient.Address,
+                TestDatabase = Enum.Parse<TestDatabases>(GetEnvironment("TESTS_DB", TestDatabases.Postgres.ToString()), true),
+                Postgres = GetEnvironment("TESTS_POSTGRES", "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"),
+                MySQL = GetEnvironment("TESTS_MYSQL", "User ID=root;Host=127.0.0.1;Port=33036;Database=btcpayserver"),
+                IntegratedLightning = MerchantCharge.Client.Uri
+            };
+            PayTester.Port = int.Parse(GetEnvironment("TESTS_PORT", Utils.FreeTcpPort().ToString(CultureInfo.InvariantCulture)), CultureInfo.InvariantCulture);
+            PayTester.HostName = GetEnvironment("TESTS_HOSTNAME", "127.0.0.1");
+            PayTester.InContainer = bool.Parse(GetEnvironment("TESTS_INCONTAINER", "false"));
+        }
 
-		public NBXplorerTester ExplorerTester
-		{
-			get; set;
-		}
-		public Network Network
-		{
-			get;
-			set;
-		} = Network.RegTest;
+        public bool Dockerized
+        {
+            get; set;
+        }
 
-		public void Dispose()
-		{
-			if(PayTester != null)
-				PayTester.Dispose();
-			if(ExplorerTester != null)
-				ExplorerTester.Dispose();
-			if(_Builder != null)
-				_Builder.Dispose();
-		}
-	}
+        public void Start()
+        {
+            PayTester.Start();
+        }
+
+        /// <summary>
+        /// Connect a customer LN node to the merchant LN node
+        /// </summary>
+        /// <returns></returns>
+        public async Task EnsureChannelsSetup()
+        {
+            Logs.Tester.LogInformation("Connecting channels");
+            await BTCPayServer.Lightning.Tests.ConnectChannels.ConnectAll(ExplorerNode, GetLightningSenderClients(), GetLightningDestClients()).ConfigureAwait(false);
+            Logs.Tester.LogInformation("Channels connected");
+        }
+
+        private IEnumerable<ILightningClient> GetLightningSenderClients()
+        {
+            yield return CustomerLightningD;
+        }
+
+        private IEnumerable<ILightningClient> GetLightningDestClients()
+        {
+            yield return MerchantLightningD;
+            yield return MerchantLnd.Client;
+        }
+
+        public void SendLightningPayment(Invoice invoice)
+        {
+            SendLightningPaymentAsync(invoice).GetAwaiter().GetResult();
+        }
+
+        public async Task SendLightningPaymentAsync(Invoice invoice)
+        {
+            var bolt11 = invoice.CryptoInfo.Where(o => o.PaymentUrls.BOLT11 != null).First().PaymentUrls.BOLT11;
+            bolt11 = bolt11.Replace("lightning:", "", StringComparison.OrdinalIgnoreCase);
+            await CustomerLightningD.Pay(bolt11);
+        }
+
+        public ILightningClient CustomerLightningD { get; set; }
+
+        public ILightningClient MerchantLightningD { get; private set; }
+        public ChargeTester MerchantCharge { get; private set; }
+        public LndMockTester MerchantLnd { get; set; }
+
+        internal string GetEnvironment(string variable, string defaultValue)
+        {
+            var var = Environment.GetEnvironmentVariable(variable);
+            return String.IsNullOrEmpty(var) ? defaultValue : var;
+        }
+
+        public TestAccount NewAccount()
+        {
+            return new TestAccount(this);
+        }
+
+        public BTCPayNetworkProvider NetworkProvider { get; private set; }
+        public RPCClient ExplorerNode
+        {
+            get; set;
+        }
+
+        public RPCClient LTCExplorerNode
+        {
+            get; set;
+        }
+
+        public ExplorerClient ExplorerClient
+        {
+            get; set;
+        }
+        public ExplorerClient LTCExplorerClient { get; set; }
+
+        HttpClient _Http = new HttpClient();
+
+        public BTCPayServerTester PayTester
+        {
+            get; set;
+        }
+
+        public List<string> Stores { get; internal set; } = new List<string>();
+
+        public void Dispose()
+        {
+            foreach (var store in Stores)
+            {
+                Xunit.Assert.True(PayTester.StoreRepository.DeleteStore(store).GetAwaiter().GetResult());
+            }
+            if (PayTester != null)
+                PayTester.Dispose();
+        }
+    }
 }

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

@@ -1,7 +1,8 @@
 using BTCPayServer.Controllers;
+using System.Linq;
 using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Models.StoreViewModels;
-using BTCPayServer.Servcices.Invoices;
+using BTCPayServer.Services.Invoices;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin;
 using NBitpayClient;
@@ -10,60 +11,160 @@ using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using NBXplorer.DerivationStrategy;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Tests.Logging;
+using BTCPayServer.Lightning;
+using BTCPayServer.Lightning.CLightning;
+using BTCPayServer.Data;
 
 namespace BTCPayServer.Tests
 {
     public class TestAccount
     {
-		ServerTester parent;
-		public TestAccount(ServerTester parent)
-		{
-			this.parent = parent;
-			BitPay = new Bitpay(new Key(), parent.PayTester.ServerUri);
-		}
+        ServerTester parent;
+        public TestAccount(ServerTester parent)
+        {
+            this.parent = parent;
+            BitPay = new Bitpay(new Key(), parent.PayTester.ServerUri);
+        }
 
-		public void GrantAccess()
-		{
-			GrantAccessAsync().GetAwaiter().GetResult();
-		}
-		public async Task GrantAccessAsync()
-		{
-			var extKey = new ExtKey().GetWif(parent.Network);
-			var pairingCode = BitPay.RequestClientAuthorization("test", Facade.Merchant);
-			var account = parent.PayTester.GetController<AccountController>();
-			await account.Register(new RegisterViewModel()
-			{
-				Email = "Bob@toto.com",
-				ConfirmPassword = "Kitten0@",
-				Password = "Kitten0@",
-			});
-			UserId = account.RegisteredUserId;
+        public void GrantAccess()
+        {
+            GrantAccessAsync().GetAwaiter().GetResult();
+        }
 
-			var store = parent.PayTester.GetController<StoresController>(account.RegisteredUserId);
-			await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
-			StoreId = store.CreatedStoreId;
+        public void Register()
+        {
+            RegisterAsync().GetAwaiter().GetResult();
+        }
 
-			await store.UpdateStore(StoreId, new StoreViewModel()
-			{
-				ExtPubKey = extKey.Neuter().ToString(),
-				SpeedPolicy = SpeedPolicy.MediumSpeed
-			});
-			Assert.IsType<ViewResult>(await store.RequestPairing(pairingCode.ToString()));
-			await store.Pair(pairingCode.ToString(), StoreId);
-		}
+        public BitcoinExtKey ExtKey
+        {
+            get; set;
+        }
 
-		public Bitpay BitPay
-		{
-			get; set;
-		}
-		public string UserId
-		{
-			get; set;
-		}
+        public async Task GrantAccessAsync()
+        {
+            await RegisterAsync();
+            await CreateStoreAsync();
+            var store = this.GetController<StoresController>();
+            var pairingCode = BitPay.RequestClientAuthorization("test", Facade.Merchant);
+            Assert.IsType<ViewResult>(await store.RequestPairing(pairingCode.ToString()));
+            await store.Pair(pairingCode.ToString(), StoreId);
+        }
+        public void CreateStore()
+        {
+            CreateStoreAsync().GetAwaiter().GetResult();
+        }
 
-		public string StoreId
-		{
-			get; set;
-		}
-	}
+        public void SetNetworkFeeMode(NetworkFeeMode mode)
+        {
+            ModifyStore((store) =>
+            {
+                store.NetworkFeeMode = mode;
+            });
+        }
+        public void ModifyStore(Action<StoreViewModel> modify)
+        {
+            var storeController = GetController<StoresController>();
+            StoreViewModel store = (StoreViewModel)((ViewResult)storeController.UpdateStore()).Model;
+            modify(store);
+            storeController.UpdateStore(store).GetAwaiter().GetResult();
+        }
+
+        public T GetController<T>(bool setImplicitStore = true) where T : Controller
+        {
+            return parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null);
+        }
+
+        public async Task CreateStoreAsync()
+        {
+            var store = this.GetController<UserStoresController>();
+            await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
+            StoreId = store.CreatedStoreId;
+            parent.Stores.Add(StoreId);
+        }
+
+        public BTCPayNetwork SupportedNetwork { get; set; }
+
+        public WalletId RegisterDerivationScheme(string crytoCode, bool segwit = false)
+        {
+            return RegisterDerivationSchemeAsync(crytoCode, segwit).GetAwaiter().GetResult();
+        }
+        public async Task<WalletId> RegisterDerivationSchemeAsync(string cryptoCode, bool segwit = false)
+        {
+            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
+            var store = parent.PayTester.GetController<StoresController>(UserId, StoreId);
+            ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
+            DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + (segwit ? "" : "-[legacy]"));
+            await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
+            {
+                DerivationScheme = DerivationScheme.ToString(),
+                Confirmation = true
+            }, cryptoCode);
+
+            return new WalletId(StoreId, cryptoCode);
+        }
+
+        public DerivationStrategyBase DerivationScheme { get; set; }
+
+        private async Task RegisterAsync()
+        {
+            var account = parent.PayTester.GetController<AccountController>();
+            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;
+        }
+        public string UserId
+        {
+            get; set;
+        }
+
+        public string StoreId
+        {
+            get; set;
+        }
+
+        public void RegisterLightningNode(string cryptoCode, LightningConnectionType connectionType)
+        {
+            RegisterLightningNodeAsync(cryptoCode, connectionType).GetAwaiter().GetResult();
+        }
+
+        public async Task RegisterLightningNodeAsync(string cryptoCode, LightningConnectionType connectionType)
+        {
+            var storeController = this.GetController<StoresController>();
+
+            string connectionString = null;
+            if (connectionType == LightningConnectionType.Charge)
+                connectionString = "type=charge;server=" + parent.MerchantCharge.Client.Uri.AbsoluteUri;
+            else if (connectionType == LightningConnectionType.CLightning)
+                connectionString = "type=clightning;server=" + ((CLightningClient)parent.MerchantLightningD).Address.AbsoluteUri;
+            else if (connectionType == LightningConnectionType.LndREST)
+                connectionString = $"type=lnd-rest;server={parent.MerchantLnd.Swagger.BaseUrl};allowinsecure=true";
+            else
+                throw new NotSupportedException(connectionType.ToString());
+
+            await storeController.AddLightningNode(StoreId, new LightningNodeViewModel()
+            {
+                ConnectionString = connectionString,
+                SkipPortTest = true
+            }, "save", "BTC");
+            if (storeController.ModelState.ErrorCount != 0)
+                Assert.False(true, storeController.ModelState.FirstOrDefault().Value.Errors[0].ErrorMessage);
+        }
+    }
 }

BTCPayServer.Tests/UtilitiesTests.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using NBitcoin.DataEncoders;
+using Newtonsoft.Json.Linq;
+using Xunit;
+using System.IO;
+
+namespace BTCPayServer.Tests
+{
+    /// <summary>
+    /// This class hold easy to run utilities for dev time
+    /// </summary>
+    public class UtilitiesTests
+    {
+        /// <summary>
+        /// Download transifex transactions and put them in BTCPayServer\wwwroot\locales
+        /// </summary>
+        [Trait("Utilities", "Utilities")]
+        [Fact]
+        public async Task PullTransifexTranslations()
+        {
+            // 1. Generate an API Token on https://www.transifex.com/user/settings/api/
+            // 2. Run "dotnet user-secrets set TransifexAPIToken <youapitoken>"
+            var client = new TransifexClient(GetTransifexAPIToken());
+            var json = await client.GetTransifexAsync("https://api.transifex.com/organizations/btcpayserver/projects/btcpayserver/resources/enjson/");
+            var langs = new[] { "en" }.Concat(((JObject)json["stats"]).Properties().Select(n => n.Name)).ToArray();
+
+            var langsDir = Path.Combine(Services.LanguageService.TryGetSolutionDirectoryInfo().FullName, "BTCPayServer", "wwwroot", "locales");
+
+            JObject sourceLang = null;
+            Task.WaitAll(langs.Select(async l =>
+            {
+                bool isSourceLang = l == "en";
+                var j = await client.GetTransifexAsync($"https://www.transifex.com/api/2/project/btcpayserver/resource/enjson/translation/{l}/");
+                if(!isSourceLang)
+                {
+                    while (sourceLang == null)
+                        await Task.Delay(10);
+                }
+                var content = j["content"].Value<string>();
+                if (l == "ne_NP")
+                    l = "np_NP";
+                if (l == "zh_CN")
+                    l = "zh-SP";
+                if (l == "kk")
+                    l = "kk-KZ";
+
+                var langCode = l.Replace("_", "-");
+                var langFile = Path.Combine(langsDir, langCode + ".json");
+                var jobj = JObject.Parse(content);
+                jobj["code"] = langCode;
+
+                if ((string)jobj["currentLanguage"] == "English" && !isSourceLang)
+                    return; // Not translated
+                if ((string)jobj["currentLanguage"] == "disable")
+                    return; // Not translated
+
+                jobj.AddFirst(new JProperty("NOTICE_WARN", "THIS CODE HAS BEEN AUTOMATICALLY GENERATED FROM TRANSIFEX, IF YOU WISH TO HELP TRANSLATION COME ON THE SLACK http://slack.btcpayserver.org TO REQUEST PERMISSION TO https://www.transifex.com/btcpayserver/btcpayserver/"));
+                if (isSourceLang)
+                {
+                    sourceLang = jobj;
+                }
+                else
+                {
+                    if(jobj["InvoiceExpired_Body_3"].Value<string>() == sourceLang["InvoiceExpired_Body_3"].Value<string>())
+                    {
+                        jobj["InvoiceExpired_Body_3"] = string.Empty;
+                    }
+                }
+                content = jobj.ToString(Newtonsoft.Json.Formatting.Indented);
+                File.WriteAllText(Path.Combine(langsDir, langFile), content);
+            }).ToArray());
+        }
+
+        private static string GetTransifexAPIToken()
+        {
+            var builder = new ConfigurationBuilder();
+            builder.AddUserSecrets("AB0AC1DD-9D26-485B-9416-56A33F268117");
+            var config = builder.Build();
+            var token = config["TransifexAPIToken"];
+            Assert.False(token == null, "TransifexAPIToken is not set.\n 1.Generate an API Token on https://www.transifex.com/user/settings/api/ \n 2.Run \"dotnet user-secrets set TransifexAPIToken <youapitoken>\"");
+            return token;
+        }
+    }
+
+    public class TransifexClient
+    {
+        public TransifexClient(string apiToken)
+        {
+            Client = new HttpClient();
+            APIToken = apiToken;
+        }
+
+        public HttpClient Client { get; }
+        public string APIToken { get; }
+
+        public async Task<JObject> GetTransifexAsync(string uri)
+        {
+            var message = new HttpRequestMessage(HttpMethod.Get, uri);
+            message.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Encoders.Base64.EncodeData(Encoding.ASCII.GetBytes($"api:{APIToken}")));
+            message.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
+            var response = await Client.SendAsync(message);
+            return await response.Content.ReadAsAsync<JObject>();
+        }
+    }
+}

BTCPayServer.Tests/Utils.cs

@@ -10,54 +10,54 @@ namespace BTCPayServer.Tests
 {
     public class Utils
     {
-		public static int FreeTcpPort()
-		{
-			TcpListener l = new TcpListener(IPAddress.Loopback, 0);
-			l.Start();
-			int port = ((IPEndPoint)l.LocalEndpoint).Port;
-			l.Stop();
-			return port;
-		}
+        public static int FreeTcpPort()
+        {
+            TcpListener l = new TcpListener(IPAddress.Loopback, 0);
+            l.Start();
+            int port = ((IPEndPoint)l.LocalEndpoint).Port;
+            l.Stop();
+            return port;
+        }
 
-		// http://stackoverflow.com/a/14933880/2061103
-		public static void DeleteDirectory(string destinationDir)
-		{
-			const int magicDust = 10;
-			for(var gnomes = 1; gnomes <= magicDust; gnomes++)
-			{
-				try
-				{
-					Directory.Delete(destinationDir, true);
-				}
-				catch(DirectoryNotFoundException)
-				{
-					return;  // good!
-				}
-				catch(IOException)
-				{
-					if(gnomes == magicDust)
-						throw;
-					// System.IO.IOException: The directory is not empty
-					System.Diagnostics.Debug.WriteLine("Gnomes prevent deletion of {0}! Applying magic dust, attempt #{1}.", destinationDir, gnomes);
+        // http://stackoverflow.com/a/14933880/2061103
+        public static void DeleteDirectory(string destinationDir)
+        {
+            const int magicDust = 10;
+            for (var gnomes = 1; gnomes <= magicDust; gnomes++)
+            {
+                try
+                {
+                    Directory.Delete(destinationDir, true);
+                }
+                catch (DirectoryNotFoundException)
+                {
+                    return;  // good!
+                }
+                catch (IOException)
+                {
+                    if (gnomes == magicDust)
+                        throw;
+                    // System.IO.IOException: The directory is not empty
+                    System.Diagnostics.Debug.WriteLine("Gnomes prevent deletion of {0}! Applying magic dust, attempt #{1}.", destinationDir, gnomes);
 
-					// see http://stackoverflow.com/questions/329355/cannot-delete-directory-with-directory-deletepath-true for more magic
-					Thread.Sleep(100);
-					continue;
-				}
-				catch(UnauthorizedAccessException)
-				{
-					if(gnomes == magicDust)
-						throw;
-					// Wait, maybe another software make us authorized a little later
-					System.Diagnostics.Debug.WriteLine("Gnomes prevent deletion of {0}! Applying magic dust, attempt #{1}.", destinationDir, gnomes);
+                    // see http://stackoverflow.com/questions/329355/cannot-delete-directory-with-directory-deletepath-true for more magic
+                    Thread.Sleep(100);
+                    continue;
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    if (gnomes == magicDust)
+                        throw;
+                    // Wait, maybe another software make us authorized a little later
+                    System.Diagnostics.Debug.WriteLine("Gnomes prevent deletion of {0}! Applying magic dust, attempt #{1}.", destinationDir, gnomes);
 
-					// see http://stackoverflow.com/questions/329355/cannot-delete-directory-with-directory-deletepath-true for more magic
-					Thread.Sleep(100);
-					continue;
-				}
-				return;
-			}
-			// depending on your use case, consider throwing an exception here
-		}
-	}
+                    // see http://stackoverflow.com/questions/329355/cannot-delete-directory-with-directory-deletepath-true for more magic
+                    Thread.Sleep(100);
+                    continue;
+                }
+                return;
+            }
+            // depending on your use case, consider throwing an exception here
+        }
+    }
 }

BTCPayServer.Tests/docker-bitcoin-cli.ps1

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

BTCPayServer.Tests/docker-bitcoin-cli.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+bitcoind_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=bitcoind)"
+docker exec -ti "$bitcoind_container_id" bitcoin-cli -datadir="/data" "$@"

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

@@ -0,0 +1,294 @@
+version: "3"    
+
+# Run `docker-compose up dev` for bootstrapping your development environment
+# Doing so will expose NBXplorer, Bitcoind RPC and postgres port to the host so that tests can Run,
+# The Visual Studio launch setting `Docker-regtest` is configured to use this environment.
+services:
+
+  tests:
+    build:
+      context: ..
+      dockerfile: BTCPayServer.Tests/Dockerfile
+    environment:
+      TESTS_BTCRPCCONNECTION: server=http://bitcoind:43782;ceiwHEbqWI83:DwubwWsoo3
+      TESTS_LTCRPCCONNECTION: server=http://litecoind:43782;ceiwHEbqWI83:DwubwWsoo3
+      TESTS_BTCNBXPLORERURL: http://nbxplorer:32838/
+      TESTS_LTCNBXPLORERURL: http://nbxplorer:32838/
+      TESTS_DB: "Postgres"
+      TESTS_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
+      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"
+      TEST_MERCHANTLND: "https://lnd:lnd@merchant_lnd:8080/"
+      TESTS_INCONTAINER: "true"
+    expose:
+      - "80"
+    links:
+      - dev
+    extra_hosts: 
+      - "tests:127.0.0.1"
+    volumes:
+      - "customer_lightningd_datadir:/etc/customer_lightningd_datadir"
+      - "merchant_lightningd_datadir:/etc/merchant_lightningd_datadir"
+
+  # 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.18.0
+    environment:
+      BITCOIN_NETWORK: regtest
+      BITCOIN_EXTRA_ARGS: |
+        deprecatedrpc=signrawtransaction
+        connect=bitcoind:39388
+    links:
+      - nbxplorer
+      - postgres
+      - mysql
+      - customer_lightningd
+      - merchant_lightningd
+      - lightning-charged
+      - customer_lnd
+      - merchant_lnd
+
+  devlnd: 
+    image: btcpayserver/bitcoin:0.18.0
+    environment:
+      BITCOIN_NETWORK: regtest
+      BITCOIN_EXTRA_ARGS: |
+        deprecatedrpc=signrawtransaction
+        connect=bitcoind:39388
+    links:
+      - nbxplorer
+      - postgres
+      - mysql
+      - customer_lnd
+      - merchant_lnd
+
+
+
+  nbxplorer:
+    image: nicolasdorier/nbxplorer:2.0.0.39
+    restart: unless-stopped
+    ports:
+      - "32838:32838"
+    expose: 
+      - "32838"
+    environment:
+      NBXPLORER_NETWORK: regtest
+      NBXPLORER_CHAINS: "btc,ltc"
+      NBXPLORER_BTCRPCURL: http://bitcoind:43782/
+      NBXPLORER_BTCNODEENDPOINT: bitcoind:39388
+      NBXPLORER_BTCRPCUSER: ceiwHEbqWI83
+      NBXPLORER_BTCRPCPASSWORD: DwubwWsoo3
+      NBXPLORER_LTCRPCURL: http://litecoind:43782/
+      NBXPLORER_LTCNODEENDPOINT: litecoind:39388
+      NBXPLORER_LTCRPCUSER: ceiwHEbqWI83
+      NBXPLORER_LTCRPCPASSWORD: DwubwWsoo3
+      NBXPLORER_BIND: 0.0.0.0:32838
+      NBXPLORER_VERBOSE: 1
+      NBXPLORER_NOAUTH: 1
+    links:
+      - bitcoind
+      - litecoind
+
+
+  bitcoind:
+    restart: unless-stopped
+    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
+        zmqpubrawtx=tcp://0.0.0.0:28333
+        deprecatedrpc=signrawtransaction
+    ports: 
+      - "43782:43782"
+    expose:
+      - "43782" # RPC
+      - "39388" # P2P
+      - "28332" # ZMQ
+      - "28333" # ZMQ
+    volumes:
+      - "bitcoin_datadir:/data"
+
+  customer_lightningd:
+    image: btcpayserver/lightning:v0.7.0-1-dev
+    stop_signal: SIGKILL
+    restart: unless-stopped
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        network=regtest
+        bind-addr=0.0.0.0
+        announce-addr=customer_lightningd
+        log-level=debug
+        dev-broadcast-interval=1000
+        dev-bitcoind-poll=1
+    ports:
+      - "30992:9835" # api port
+    expose:
+      - "9735" # server port
+      - "9835" # api port
+    volumes:
+      - "bitcoin_datadir:/etc/bitcoin"
+      - "customer_lightningd_datadir:/root/.lightning"
+    links:
+      - bitcoind
+
+  lightning-charged:
+    image: shesek/lightning-charge:0.4.6-standalone
+    restart: unless-stopped
+    environment:
+      NETWORK: regtest
+      API_TOKEN: foiewnccewuify
+      BITCOIND_RPCCONNECT: bitcoind
+    volumes:
+      - "bitcoin_datadir:/etc/bitcoin"
+      - "lightning_charge_datadir:/data"
+      - "merchant_lightningd_datadir:/etc/lightning"
+    expose:
+      - "9112" # Charge
+      - "9735" # Lightning
+    ports:
+      - "54938:9112" # Charge
+    links:
+      - bitcoind
+      - merchant_lightningd
+
+  merchant_lightningd:
+    image: btcpayserver/lightning:v0.7.0-1-dev
+    stop_signal: SIGKILL
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        bind-addr=0.0.0.0
+        announce-addr=merchant_lightningd
+        network=regtest
+        log-level=debug
+        dev-broadcast-interval=1000
+    ports:
+      - "30993:9835" # api port
+    expose:
+      - "9735" # server port
+      - "9835" # api port
+    volumes:
+      - "bitcoin_datadir:/etc/bitcoin"
+      - "merchant_lightningd_datadir:/root/.lightning"
+    links:
+      - bitcoind
+
+  litecoind:
+    restart: unless-stopped
+    image: nicolasdorier/docker-litecoin:0.16.3
+    environment:
+      BITCOIN_EXTRA_ARGS: |-
+        rpcuser=ceiwHEbqWI83
+        rpcpassword=DwubwWsoo3
+        regtest=1
+        rpcport=43782
+        port=39388
+        whitelist=0.0.0.0/0
+    ports: 
+      - "43783:43782"
+    expose:
+      - "43782" # RPC
+      - "39388" # P2P
+
+  postgres:
+    image:  postgres:9.6.5
+    ports:
+      - "39372:5432"
+    expose:
+      - "5432"
+      
+  mysql:
+    image:  mysql:8.0.12
+    expose:
+      - "3306"
+    ports:
+      - "33036:3306"
+    environment:
+      - MYSQL_ALLOW_EMPTY_PASSWORD=yes
+
+  merchant_lnd:
+    image: btcpayserver/lnd:v0.6-beta
+    restart: unless-stopped
+    environment:
+      LND_CHAIN: "btc"
+      LND_ENVIRONMENT: "regtest"
+      LND_EXPLORERURL: "http://nbxplorer:32838/"
+      LND_EXTRA_ARGS: |
+        restlisten=0.0.0.0:8080
+        rpclisten=127.0.0.1:10008
+        rpclisten=0.0.0.0:10009
+        bitcoin.node=bitcoind
+        bitcoind.rpchost=bitcoind:43782
+        bitcoind.zmqpubrawblock=tcp://bitcoind:28332
+        bitcoind.zmqpubrawtx=tcp://bitcoind:28333
+        externalip=merchant_lnd:9735
+        no-macaroons=1
+        debuglevel=debug
+        noseedbackup=1
+        trickledelay=1000
+    ports:
+      - "53280:8080"
+    expose:
+      - "9735"
+    volumes:
+      - "merchant_lnd_datadir:/data"
+      - "bitcoin_datadir:/deps/.bitcoin"
+    links:
+      - bitcoind
+
+  customer_lnd:
+    image: btcpayserver/lnd:v0.6-beta
+    restart: unless-stopped
+    environment:
+      LND_CHAIN: "btc"
+      LND_ENVIRONMENT: "regtest"
+      LND_EXPLORERURL: "http://nbxplorer:32838/"
+      LND_EXTRA_ARGS: |
+        restlisten=0.0.0.0:8080
+        rpclisten=127.0.0.1:10008
+        rpclisten=0.0.0.0:10009
+        bitcoin.node=bitcoind
+        bitcoind.rpchost=bitcoind:43782
+        bitcoind.zmqpubrawblock=tcp://bitcoind:28332
+        bitcoind.zmqpubrawtx=tcp://bitcoind:28333
+        externalip=customer_lnd:10009
+        no-macaroons=1
+        debuglevel=debug
+        noseedbackup=1
+        trickledelay=1000
+    ports:
+      - "53281:8080"
+    expose:
+      - "8080"
+      - "10009"
+    volumes:
+      - "customer_lnd_datadir:/root/.lnd"
+      - "bitcoin_datadir:/deps/.bitcoin"
+    links:
+      - bitcoind
+
+volumes:
+    bitcoin_datadir:
+    customer_lightningd_datadir:
+    merchant_lightningd_datadir:
+    lightning_charge_datadir:
+    customer_lnd_datadir:
+    merchant_lnd_datadir:

BTCPayServer.Tests/docker-customer-lightning-cli.ps1

@@ -0,0 +1,2 @@
+$customer_lightning_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=customer_lightningd)
+docker exec -ti $customer_lightning_container_id lightning-cli $args

BTCPayServer.Tests/docker-customer-lightning-cli.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+customer_lightning_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=customer_lightningd)"
+docker exec -ti $customer_lightning_container_id lightning-cli "$@"

BTCPayServer.Tests/docker-entrypoint.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+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.Tests/docker-litecoin-cli.ps1

@@ -0,0 +1,2 @@
+$litecoind_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=litecoind)
+docker exec -ti $litecoind_container_id litecoin-cli -datadir="/data" $args

BTCPayServer.Tests/docker-litecoin-cli.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+litecoind_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=litecoind)"
+docker exec -ti "$litecoind_container_id" litecoin-cli -datadir="/data" "$@"

BTCPayServer.Tests/docker-merchant-lightning-cli.ps1

@@ -0,0 +1,2 @@
+$merchant_lightning_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=merchant_lightningd)
+docker exec -ti $merchant_lightning_container_id lightning-cli $args

BTCPayServer.Tests/docker-merchant-lightning-cli.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+merchant_lightning_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=merchant_lightningd)"
+docker exec -ti $merchant_lightning_container_id lightning-cli "$@"

BTCPayServer.Tests/xunit.runner.json

@@ -0,0 +1,5 @@
+{
+    "parallelizeTestCollections": false,
+    "longRunningTestSeconds": 60,
+    "diagnosticMessages": true
+}

BTCPayServer/.dockerignore

@@ -1,123 +0,0 @@
-# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
-[Bb]in/
-[Oo]bj/
-node_modules/
-dist/
-
-# mstest test results
-TestResults
-
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-
-# User-specific files
-*.suo
-*.user
-*.sln.docstates
-
-# Build results
-[Dd]ebug/
-[Rr]elease/
-x64/
-*_i.c
-*_p.c
-*.ilk
-*.meta
-*.obj
-*.pch
-*.pdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.log
-*.vspscc
-*.vssscc
-.builds
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opensdf
-*.sdf
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*
-
-# NCrunch
-*.ncrunch*
-.*crunch*.local.xml
-
-# Installshield output folder 
-[Ee]xpress
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish
-
-# Publish Web Output
-*.Publish.xml
-
-# NuGet Packages Directory
-packages
-
-# Windows Azure Build Output
-csx
-*.build.csdef
-
-# Windows Store app package directory
-AppPackages/
-
-# Others
-[Bb]in
-[Oo]bj
-sql
-TestResults
-[Tt]est[Rr]esult*
-*.Cache
-ClientBin
-[Ss]tyle[Cc]op.*
-~$*
-*.dbmdl
-Generated_Code #added for RIA/Silverlight projects
-
-# Backup & report files from converting an old project file to a newer
-# Visual Studio version. Backup files are not needed, because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-
-src/Rapporteringsregisteret.Web/assets/less/*.css
-
-MetricResults/
-*.sln.ide/
-
-_configs/
-
-# vnext stuff
-bower_components
-output
-
-.vs

BTCPayServer/Authentication/BitIdentity.cs

@@ -1,35 +0,0 @@
-using NBitcoin;
-using NBitcoin.DataEncoders;
-using System;
-using System.Collections.Generic;
-using System.Security.Principal;
-using System.Text;
-
-namespace BTCPayServer.Authentication
-{
-    public class BitIdentity : IIdentity
-    {
-		public BitIdentity(PubKey key)
-		{
-			PubKey = key;
-			_Name = Encoders.Base58Check.EncodeData(Encoders.Hex.DecodeData("0f02" + key.Hash.ToString()));
-			SIN = NBitpayClient.Extensions.BitIdExtensions.GetBitIDSIN(key);
-		}
-		string _Name;
-
-		public string SIN
-		{
-			get;
-		}
-		public PubKey PubKey
-		{
-			get;
-		}
-
-		public string AuthenticationType => "BitID";
-
-		public bool IsAuthenticated => true;
-
-		public string Name => _Name;
-	}
-}

BTCPayServer/Authentication/BitToken.cs

@@ -8,53 +8,38 @@ namespace BTCPayServer.Authentication
 {
     public class BitTokenEntity
     {
-		public string Name
-		{
-			get; set;
-		}
-		public string Value
-		{
-			get; set;
-		}
-		public DateTimeOffset DateCreated
-		{
-			get; set;
-		}
-		public bool Active
-		{
-			get; set;
-		}
-		public string PairedId
-		{
-			get; set;
-		}
-		public string Label
-		{
-			get; set;
-		}
-		public DateTimeOffset PairingTime
-		{
-			get; set;
-		}
-		public string SIN
-		{
-			get;
-			set;
-		}
+        public string Value
+        {
+            get; set;
+        }
+        public string StoreId
+        {
+            get; set;
+        }
+        public string Label
+        {
+            get; set;
+        }
+        public DateTimeOffset PairingTime
+        {
+            get; set;
+        }
+        public string SIN
+        {
+            get;
+            set;
+        }
 
-		public BitTokenEntity Clone(Facade facade)
-		{
-			return new BitTokenEntity()
-			{
-				Active = Active,
-				DateCreated = DateCreated,
-				Label = Label,
-				Name = Name,
-				PairedId = PairedId,
-				PairingTime = PairingTime,
-				SIN = SIN,
-				Value = Value
-			};
-		}
-	}
+        public BitTokenEntity Clone(Facade facade)
+        {
+            return new BitTokenEntity()
+            {
+                Label = Label,
+                StoreId = StoreId,
+                PairingTime = PairingTime,
+                SIN = SIN,
+                Value = Value
+            };
+        }
+    }
 }

BTCPayServer/Authentication/PairingCodeEntity.cs

@@ -4,47 +4,42 @@ using System.Text;
 
 namespace BTCPayServer.Authentication
 {
-	public class PairingCodeEntity
-	{
-		public string Id
-		{
-			get;
-			set;
-		}
-		public string Facade
-		{
-			get;
-			set;
-		}
-		public string Label
-		{
-			get;
-			set;
-		}
-		public string SIN
-		{
-			get;
-			set;
-		}
-		public DateTimeOffset PairingTime
-		{
-			get;
-			set;
-		}
-		public DateTimeOffset PairingExpiration
-		{
-			get;
-			set;
-		}
-		public string Token
-		{
-			get;
-			set;
-		}
+    public class PairingCodeEntity
+    {
+        public string Id
+        {
+            get;
+            set;
+        }
+        public string Label
+        {
+            get;
+            set;
+        }
+        public string SIN
+        {
+            get;
+            set;
+        }
+        public DateTimeOffset CreatedTime
+        {
+            get;
+            set;
+        }
+        public DateTimeOffset Expiration
+        {
+            get;
+            set;
+        }
+        public string TokenValue
+        {
+            get;
+            set;
+        }
 
-		public bool IsExpired()
-		{
-			return DateTimeOffset.UtcNow > PairingExpiration;
-		}
-	}
+        public bool IsExpired()
+        {
+            return DateTimeOffset.UtcNow > Expiration;
+        }
+    }
 }

BTCPayServer/Authentication/TokenRepository.cs

@@ -1,4 +1,5 @@
-using DBreeze;
+using BTCPayServer.Data;
+using DBriize;
 using NBitcoin;
 using NBitcoin.DataEncoders;
 using Newtonsoft.Json;
@@ -6,177 +7,242 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Query;
+using System.Linq;
 
 namespace BTCPayServer.Authentication
 {
-	public class TokenRepository
-	{
-		public TokenRepository(DBreezeEngine engine)
-		{
-			_Engine = engine;
-		}
+    public enum PairingResult
+    {
+        Partial,
+        Complete,
+        ReusedKey,
+        Expired
+    }
+
+    public class TokenRepository
+    {
+        ApplicationDbContextFactory _Factory;
+        public TokenRepository(ApplicationDbContextFactory dbFactory)
+        {
+            if (dbFactory == null)
+                throw new ArgumentNullException(nameof(dbFactory));
+            _Factory = dbFactory;
+        }
+
+        public async Task<BitTokenEntity[]> GetTokens(string sin)
+        {
+            if (sin == null)
+                return Array.Empty<BitTokenEntity>();
+            using (var ctx = _Factory.CreateContext())
+            {
+                return (await ctx.PairedSINData
+                    .Where(p => p.SIN == sin)
+                    .ToListAsync())
+                    .Select(p => CreateTokenEntity(p))
+                    .ToArray();
+            }
+        }
+
+        public async Task<String> GetStoreIdFromAPIKey(string apiKey)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return await ctx.ApiKeys.Where(o => o.Id == apiKey).Select(o => o.StoreId).FirstOrDefaultAsync();
+            }
+        }
+
+        public async Task GenerateLegacyAPIKey(string storeId)
+        {
+            // It is legacy support and Bitpay generate string of unknown format, trying to replicate them
+            // as good as possible. The string below got generated for me.
+            var chars = "ERo0vkBMOYhyU0ZHvirCplbLDIGWPdi1ok77VnW7QdE";
+            var rand = new Random(Math.Abs(RandomUtils.GetInt32()));
+            var generated = new char[chars.Length];
+            for (int i = 0; i < generated.Length; i++)
+            {
+                generated[i] = chars[rand.Next(0, generated.Length)];
+            }
+
+            using (var ctx = _Factory.CreateContext())
+            {
+                var existing = await ctx.ApiKeys.Where(o => o.StoreId == storeId).FirstOrDefaultAsync();
+                if (existing != null)
+                {
+                    ctx.ApiKeys.Remove(existing);
+                }
+                ctx.ApiKeys.Add(new APIKeyData() { Id = new string(generated), StoreId = storeId });
+                await ctx.SaveChangesAsync().ConfigureAwait(false);
+            }
+        }
+
+        public async Task<string[]> GetLegacyAPIKeys(string storeId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return await ctx.ApiKeys.Where(o => o.StoreId == storeId).Select(c => c.Id).ToArrayAsync();
+            }
+        }
+
+        private BitTokenEntity CreateTokenEntity(PairedSINData data)
+        {
+            return new BitTokenEntity()
+            {
+                Label = data.Label,
+                Value = data.Id,
+                SIN = data.SIN,
+                PairingTime = data.PairingTime,
+                StoreId = data.StoreDataId
+            };
+        }
+
+        public async Task<string> CreatePairingCodeAsync()
+        {
+            string pairingCodeId = null;
+            while (true)
+            {
+                pairingCodeId = Encoders.Base58.EncodeData(RandomUtils.GetBytes(6));
+                if (pairingCodeId.Length == 7) // woocommerce plugin check for exactly 7 digits
+                    break;
+            }
+            using (var ctx = _Factory.CreateContext())
+            {
+                var now = DateTime.UtcNow;
+                var expiration = DateTime.UtcNow + TimeSpan.FromMinutes(15);
+                ctx.PairingCodes.Add(new PairingCodeData()
+                {
+                    Id = pairingCodeId,
+                    DateCreated = now,
+                    Expiration = expiration,
+                    TokenValue = Encoders.Base58.EncodeData(RandomUtils.GetBytes(32))
+                });
+                await ctx.SaveChangesAsync();
+            }
+            return pairingCodeId;
+        }
+
+        public async Task<PairingCodeEntity> UpdatePairingCode(PairingCodeEntity pairingCodeEntity)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                var pairingCode = await ctx.PairingCodes.FindAsync(pairingCodeEntity.Id);
+                pairingCode.Label = pairingCodeEntity.Label;
+                await ctx.SaveChangesAsync();
+                return CreatePairingCodeEntity(pairingCode);
+            }
+        }
+
+        public async Task<PairingResult> PairWithStoreAsync(string pairingCodeId, string storeId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                var pairingCode = await ctx.PairingCodes.FindAsync(pairingCodeId);
+                if (pairingCode == null || pairingCode.Expiration < DateTimeOffset.UtcNow)
+                    return PairingResult.Expired;
+                pairingCode.StoreDataId = storeId;
+                var result = await ActivateIfComplete(ctx, pairingCode);
+                await ctx.SaveChangesAsync();
+                return result;
+            }
+        }
+
+        public async Task<PairingResult> PairWithSINAsync(string pairingCodeId, string sin)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                var pairingCode = await ctx.PairingCodes.FindAsync(pairingCodeId);
+                if (pairingCode == null || pairingCode.Expiration < DateTimeOffset.UtcNow)
+                    return PairingResult.Expired;
+                pairingCode.SIN = sin;
+                var result = await ActivateIfComplete(ctx, pairingCode);
+                await ctx.SaveChangesAsync();
+                return result;
+            }
+        }
 
 
-		private readonly DBreezeEngine _Engine;
-		public DBreezeEngine Engine
-		{
-			get
-			{
-				return _Engine;
-			}
-		}
+        private async Task<PairingResult> ActivateIfComplete(ApplicationDbContext ctx, PairingCodeData pairingCode)
+        {
+            if (!string.IsNullOrEmpty(pairingCode.SIN) && !string.IsNullOrEmpty(pairingCode.StoreDataId))
+            {
+                ctx.PairingCodes.Remove(pairingCode);
 
-		public Task<BitTokenEntity[]> GetTokens(string sin)
-		{
-			List<BitTokenEntity> tokens = new List<BitTokenEntity>();
-			using(var tx = _Engine.GetTransaction())
-			{
-				tx.ValuesLazyLoadingIsOn = false;
-				foreach(var row in tx.SelectForward<string, byte[]>($"T_{sin}"))
-				{
-					var token = ToObject<BitTokenEntity>(row.Value);
-					tokens.Add(token);
-				}
-			}
-			return Task.FromResult(tokens.ToArray());
-		}
-
-		public Task<BitTokenEntity> CreateToken(string sin, string tokenName)
-		{
-			var token = new BitTokenEntity
-			{
-				Name = tokenName,
-				Value = Encoders.Base58.EncodeData(RandomUtils.GetBytes(32)),
-				DateCreated = DateTimeOffset.UtcNow
-			};
-			using(var tx = _Engine.GetTransaction())
-			{
-				tx.Insert<string, byte[]>($"T_{sin}", token.Name, ToBytes(token));
-				tx.Commit();
-			}
-			return Task.FromResult(token);
-		}
-
-		public Task<bool> PairWithAsync(string pairingCode, string pairedId)
-		{
-			if(pairedId == null)
-				throw new ArgumentNullException(nameof(pairedId));
-			using(var tx = _Engine.GetTransaction())
-			{
-				var row = tx.Select<string, byte[]>("PairingCodes", pairingCode);
-				if(row == null || !row.Exists)
-					return Task.FromResult(false);
-				tx.RemoveKey<string>("PairingCodes", pairingCode);
-				try
-				{
-					var pairingEntity = ToObject<PairingCodeEntity>(row.Value);
-					if(pairingEntity.IsExpired())
-						return Task.FromResult(false);
-					row = tx.Select<string, byte[]>($"T_{pairingEntity.SIN}", pairingEntity.Facade);
-					if(row == null || !row.Exists)
-						return Task.FromResult(false);
-					var token = ToObject<BitTokenEntity>(row.Value);
-					if(token.Active)
-						return Task.FromResult(false);
-					token.Active = true;
-					token.PairedId = pairedId;
-					token.SIN = pairingEntity.SIN;
-					token.Label = pairingEntity.Label;
-					token.PairingTime = DateTimeOffset.UtcNow;
-					tx.Insert($"TbP_{pairedId}", token.Value, ToBytes(token));
-					tx.Insert($"T_{pairingEntity.SIN}", pairingEntity.Facade, ToBytes(token));
-				}
-				finally
-				{
-					tx.Commit();
-				}
-			}
-			return Task.FromResult(true);
-		}
-
-		public Task<BitTokenEntity[]> GetTokensByPairedIdAsync(string pairedId)
-		{
-			List<BitTokenEntity> tokens = new List<BitTokenEntity>();
-			using(var tx = _Engine.GetTransaction())
-			{
-				tx.ValuesLazyLoadingIsOn = false;
-				foreach(var row in tx.SelectForward<string, byte[]>($"TbP_{pairedId}"))
-				{
-					tokens.Add(ToObject<BitTokenEntity>(row.Value));
-				}
-			}
-			return Task.FromResult(tokens.ToArray());
-		}
-
-		public Task<PairingCodeEntity> GetPairingAsync(string pairingCode)
-		{
-			using(var tx = _Engine.GetTransaction())
-			{
-				var row = tx.Select<string, byte[]>("PairingCodes", pairingCode);
-				if(row == null || !row.Exists)
-					return Task.FromResult<PairingCodeEntity>(null);
-				var pairingEntity = ToObject<PairingCodeEntity>(row.Value);
-				if(pairingEntity.IsExpired())
-					return Task.FromResult<PairingCodeEntity>(null);
-				return Task.FromResult(pairingEntity);
-			}
-		}
-		public Task<PairingCodeEntity> AddPairingCodeAsync(PairingCodeEntity pairingCodeEntity)
-		{
-			pairingCodeEntity = Clone(pairingCodeEntity);
-			pairingCodeEntity.Id = Encoders.Base58.EncodeData(RandomUtils.GetBytes(6));
-			using(var tx = _Engine.GetTransaction())
-			{
-				tx.Insert("PairingCodes", pairingCodeEntity.Id, ToBytes(pairingCodeEntity));
-				tx.Commit();
-			}
-			return Task.FromResult(pairingCodeEntity);
-		}
-
-		private byte[] ToBytes<T>(T obj)
-		{
-			return ZipUtils.Zip(JsonConvert.SerializeObject(obj));
-		}
-		private T ToObject<T>(byte[] value)
-		{
-			return JsonConvert.DeserializeObject<T>(ZipUtils.Unzip(value));
-		}
-
-		private T Clone<T>(T obj)
-		{
-			return ToObject<T>(ToBytes(obj));
-		}
+                // Can have concurrency issues... but no harm can be done
+                var alreadyUsed = await ctx.PairedSINData.Where(p => p.SIN == pairingCode.SIN && p.StoreDataId != pairingCode.StoreDataId).AnyAsync();
+                if (alreadyUsed)
+                    return PairingResult.ReusedKey;
+                await ctx.PairedSINData.AddAsync(new PairedSINData()
+                {
+                    Id = pairingCode.TokenValue,
+                    PairingTime = DateTime.UtcNow,
+                    Label = pairingCode.Label,
+                    StoreDataId = pairingCode.StoreDataId,
+                    SIN = pairingCode.SIN
+                });
+                return PairingResult.Complete;
+            }
+            return PairingResult.Partial;
+        }
 
 
-		public async Task<bool> DeleteToken(string sin, string tokenName, string storeId)
-		{
-			var token = await GetToken(sin, tokenName);
-			if(token == null || (token.PairedId != null && token.PairedId != storeId))
-				return false;
-			using(var tx = _Engine.GetTransaction())
-			{
-				tx.RemoveKey<string>($"T_{sin}", tokenName);
-				if(token.PairedId != null)
-					tx.RemoveKey<string>($"TbP_" + token.PairedId, token.Value);
-				tx.Commit();
-			}
-			return true;
-		}
+        public async Task<BitTokenEntity[]> GetTokensByStoreIdAsync(string storeId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return (await ctx.PairedSINData.Where(p => p.StoreDataId == storeId).ToListAsync())
+                        .Select(c => CreateTokenEntity(c))
+                        .ToArray();
+            }
+        }
 
-		private Task<BitTokenEntity> GetToken(string sin, string tokenName)
-		{
-			using(var tx = _Engine.GetTransaction())
-			{
-				tx.ValuesLazyLoadingIsOn = true;
-				var row = tx.Select<string, byte[]>($"T_{sin}", tokenName);
-				if(row == null || !row.Exists)
-					return Task.FromResult<BitTokenEntity>(null);
-				var token = ToObject<BitTokenEntity>(row.Value);
-				if(!token.Active)
-					return Task.FromResult<BitTokenEntity>(null);
-				return Task.FromResult(token);
-			}
-		}
+        public async Task<PairingCodeEntity> GetPairingAsync(string pairingCode)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return CreatePairingCodeEntity(await ctx.PairingCodes.FindAsync(pairingCode));
+            }
+        }
 
-	}
+        private PairingCodeEntity CreatePairingCodeEntity(PairingCodeData data)
+        {
+            if (data == null)
+                return null;
+            return new PairingCodeEntity()
+            {
+                Id = data.Id,
+                Label = data.Label,
+                Expiration = data.Expiration,
+                CreatedTime = data.DateCreated,
+                TokenValue = data.TokenValue,
+                SIN = data.SIN
+            };
+        }
+
+
+        public async Task<bool> DeleteToken(string tokenId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                var token = await ctx.PairedSINData.FindAsync(tokenId);
+                if (token == null)
+                    return false;
+                ctx.PairedSINData.Remove(token);
+                await ctx.SaveChangesAsync();
+                return true;
+            }
+        }
+
+        public async Task<BitTokenEntity> GetToken(string tokenId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                var token = await ctx.PairedSINData.FindAsync(tokenId);
+                if (token == null)
+                    return null;
+                return CreateTokenEntity(token);
+            }
+        }
+
+    }
 }

BTCPayServer/BTCPayNetwork.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public class BTCPayDefaultSettings
+    {
+        static BTCPayDefaultSettings()
+        {
+            _Settings = new Dictionary<NetworkType, BTCPayDefaultSettings>();
+            foreach (var chainType in new[] { NetworkType.Mainnet, NetworkType.Testnet, NetworkType.Regtest })
+            {
+                var settings = new BTCPayDefaultSettings();
+                _Settings.Add(chainType, settings);
+                settings.DefaultDataDirectory = StandardConfiguration.DefaultDataDirectory.GetDirectory("BTCPayServer", NBXplorerDefaultSettings.GetFolderName(chainType));
+                settings.DefaultConfigurationFile = Path.Combine(settings.DefaultDataDirectory, "settings.config");
+                settings.DefaultPort = (chainType == NetworkType.Mainnet ? 23000 :
+                                                      chainType == NetworkType.Regtest ? 23002 :
+                                                      chainType == NetworkType.Testnet ? 23001 : throw new NotSupportedException(chainType.ToString()));
+            }
+        }
+
+        static Dictionary<NetworkType, BTCPayDefaultSettings> _Settings;
+
+        public static BTCPayDefaultSettings GetDefaultSettings(NetworkType chainType)
+        {
+            return _Settings[chainType];
+        }
+
+        public string DefaultDataDirectory { get; set; }
+        public string DefaultConfigurationFile { get; set; }
+        public int DefaultPort { get; set; }
+    }
+    public class BTCPayNetwork
+    {
+        public Network NBitcoinNetwork { get; set; }
+        public string CryptoCode { get; internal set; }
+        public string BlockExplorerLink { get; internal set; }
+        public string UriScheme { get; internal set; }
+        public Money MinFee { get; internal set; }
+        public string DisplayName { get; set; }
+
+        [Obsolete("Should not be needed")]
+        public bool IsBTC
+        {
+            get
+            {
+                return CryptoCode == "BTC";
+            }
+        }
+
+        public string CryptoImagePath { get; set; }
+        public string LightningImagePath { get; set; }
+        public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
+
+        public BTCPayDefaultSettings DefaultSettings { get; set; }
+        public KeyPath CoinType { get; internal set; }
+        public int MaxTrackedConfirmation { get; internal set; } = 6;
+        public string[] DefaultRateRules { get; internal set; } = Array.Empty<string>();
+        public bool SupportRBF { get; internal set; }
+
+        public override string ToString()
+        {
+            return CryptoCode;
+        }
+
+        internal KeyPath GetRootKeyPath()
+        {
+            return new KeyPath(NBitcoinNetwork.Consensus.SupportSegwit ? "49'" : "44'")
+                        .Derive(CoinType); 
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBitpayClient;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Bitcoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoin",
+                CryptoImagePath = "imlegacy/bitcoin.svg",
+                LightningImagePath = "imlegacy/bitcoin-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'"),
+                SupportRBF = true
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.BitcoinGold.cs

@@ -0,0 +1,30 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoinGold()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTG");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "BGold",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://explorer.bitcoingold.org/insight/tx/{0}/" : "https://test-explorer.bitcoingold.org/insight/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoingold",
+                DefaultRateRules = new[]
+                {
+                    "BTG_X = BTG_BTC * BTC_X",
+                    "BTG_BTC = bitfinex(BTG_BTC)",
+                },
+                CryptoImagePath = "imlegacy/btg.svg",
+                LightningImagePath = "imlegacy/btg-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("156'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Bitcoinplus.cs

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

BTCPayServer/BTCPayNetworkProvider.Bitcore.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcore()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTX");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Bitcore",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://insight.bitcore.cc/tx/{0}" : "https://insight.bitcore.cc/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcore",
+                DefaultRateRules = new[]
+                {
+                                "BTX_X = BTX_BTC * BTC_X",
+                                "BTX_BTC = hitbtc(BTX_BTC)"
+                },
+                CryptoImagePath = "imlegacy/bitcore.svg",
+                LightningImagePath = "imlegacy/bitcore-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("160'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Dash.cs

@@ -0,0 +1,35 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitDash()
+        {
+            //not needed: NBitcoin.Altcoins.Dash.Instance.EnsureRegistered();
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("DASH");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Dash",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet
+                    ? "https://insight.dash.org/insight/tx/{0}"
+                    : "https://testnet-insight.dashevo.org/insight/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "dash",
+                DefaultRateRules = new[]
+                    {
+                        "DASH_X = DASH_BTC * BTC_X",
+                        "DASH_BTC = bittrex(DASH_BTC)"
+                    },
+                CryptoImagePath = "imlegacy/dash.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                //https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("5'")
+                    : new KeyPath("1'"),
+                MinFee = Money.Satoshis(1m)
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Dogecoin.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitDogecoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("DOGE");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Dogecoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://dogechain.info/tx/{0}" : "https://dogechain.info/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "dogecoin",
+                DefaultRateRules = new[] 
+                {
+                                "DOGE_X = DOGE_BTC * BTC_X",
+                                "DOGE_BTC = bittrex(DOGE_BTC)"
+                },
+                CryptoImagePath = "imlegacy/dogecoin.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("3'") : new KeyPath("1'"),
+                MinFee = Money.Coins(1m)
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Feathercoin.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitFeathercoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("FTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Feathercoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://explorer.feathercoin.com/tx/{0}" : "https://explorer.feathercoin.com/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "feathercoin",
+                DefaultRateRules = new[] 
+                {
+                                "FTC_X = FTC_BTC * BTC_X",
+                                "FTC_BTC = bittrex(FTC_BTC)"
+                },
+                CryptoImagePath = "imlegacy/feathercoin.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("8'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Groestlcoin.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitGroestlcoin()
+        {
+
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("GRS");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Groestlcoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://chainz.cryptoid.info/grs/tx.dws?{0}.htm" : "https://chainz.cryptoid.info/grs-test/tx.dws?{0}.htm",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "groestlcoin",
+                DefaultRateRules = new[]
+                {
+                                "GRS_X = GRS_BTC * BTC_X",
+                                "GRS_BTC = bittrex(GRS_BTC)"
+                },
+                CryptoImagePath = "imlegacy/groestlcoin.png",
+                LightningImagePath = "imlegacy/groestlcoin-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("17'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Litecoin.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitLitecoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("LTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Litecoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://live.blockcypher.com/ltc/tx/{0}/" : "http://explorer.litecointools.com/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "litecoin",
+                CryptoImagePath = "imlegacy/litecoin.svg",
+                LightningImagePath = "imlegacy/litecoin-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("2'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Monacoin.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitMonacoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("MONA");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Monacoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://mona.insight.monaco-ex.org/insight/tx/{0}" : "https://testnet-mona.insight.monaco-ex.org/insight/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "monacoin",
+                DefaultRateRules = new[] 
+                {
+                                "MONA_X = MONA_BTC * BTC_X",
+                                "MONA_BTC = bittrex(MONA_BTC)"
+                },
+                CryptoImagePath = "imlegacy/monacoin.png",
+                LightningImagePath = "imlegacy/mona-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("22'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Polis.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitPolis()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("POLIS");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Polis",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://insight.polispay.org/tx/{0}" : "https://insight.polispay.org/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "polis",
+                DefaultRateRules = new[]
+                {
+                                "POLIS_X = POLIS_BTC * BTC_X",
+                                "POLIS_BTC = cryptopia(POLIS_BTC)"
+                },
+                CryptoImagePath = "imlegacy/polis.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("1997'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Ufo.cs

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

BTCPayServer/BTCPayNetworkProvider.Viacoin.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitViacoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("VIA");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Viacoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://explorer.viacoin.org/tx/{0}" : "https://explorer.viacoin.org/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "viacoin",
+                DefaultRateRules = new[]
+                {
+                                "VIA_X = VIA_BTC * BTC_X",
+                                "VIA_BTC = bittrex(VIA_BTC)"
+                },
+                CryptoImagePath = "imlegacy/viacoin.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("14'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using Microsoft.Extensions.Caching.Memory;
+using NBitcoin;
+using NBitpayClient;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        Dictionary<string, BTCPayNetwork> _Networks = new Dictionary<string, BTCPayNetwork>();
+
+
+        private readonly NBXplorerNetworkProvider _NBXplorerNetworkProvider;
+        public NBXplorerNetworkProvider NBXplorerNetworkProvider
+        {
+            get
+            {
+                return _NBXplorerNetworkProvider;
+            }
+        }
+
+        BTCPayNetworkProvider(BTCPayNetworkProvider filtered, string[] cryptoCodes)
+        {
+            NetworkType = filtered.NetworkType;
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(filtered.NetworkType);
+            _Networks = new Dictionary<string, BTCPayNetwork>();
+            cryptoCodes = cryptoCodes.Select(c => c.ToUpperInvariant()).ToArray();
+            foreach (var network in filtered._Networks)
+            {
+                if(cryptoCodes.Contains(network.Key))
+                {
+                    _Networks.Add(network.Key, network.Value);
+                }
+            }
+        }
+
+        public NetworkType NetworkType { get; private set; }
+        public BTCPayNetworkProvider(NetworkType networkType)
+        {
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(networkType);
+            NetworkType = networkType;
+            InitBitcoin();
+            InitLitecoin();
+            InitBitcore();
+            InitDogecoin();
+            InitBitcoinGold();
+            InitMonacoin();
+            InitDash();
+            InitFeathercoin();
+            InitGroestlcoin();
+            InitViacoin();
+
+            // Disabled because of https://twitter.com/Cryptopia_NZ/status/1085084168852291586
+            //InitPolis();
+            //InitBitcoinplus();
+            //InitUfo();
+        }
+
+        /// <summary>
+        /// Keep only the specified crypto
+        /// </summary>
+        /// <param name="cryptoCodes">Crypto to support</param>
+        /// <returns></returns>
+        public BTCPayNetworkProvider Filter(string[] cryptoCodes)
+        {
+            return new BTCPayNetworkProvider(this, cryptoCodes);
+        }
+
+        [Obsolete("To use only for legacy stuff")]
+        public BTCPayNetwork BTC
+        {
+            get
+            {
+                return GetNetwork("BTC");
+            }
+        }
+
+        public void Add(BTCPayNetwork network)
+        {
+            _Networks.Add(network.CryptoCode.ToUpperInvariant(), network);
+        }
+
+        public IEnumerable<BTCPayNetwork> GetAll()
+        {
+            return _Networks.Values.ToArray();
+        }
+
+        public bool Support(string cryptoCode)
+        {
+            return _Networks.ContainsKey(cryptoCode.ToUpperInvariant());
+        }
+
+        public BTCPayNetwork GetNetwork(string cryptoCode)
+        {
+            if(!_Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetwork network))
+            {
+                if (cryptoCode == "XBT")
+                    return GetNetwork("BTC");
+            }
+            return network;
+        }
+    }
+}

BTCPayServer/BTCPayServer.csproj

@@ -1,59 +1,91 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.0</Version>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+		<Version>1.0.3.97</Version>
+    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup>
+    <LangVersion>7.3</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
+    <Compile Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <Compile Remove="wwwroot\css\**" />
+    <Compile Remove="wwwroot\vendor\jquery-nice-select\**" />
     <Content Remove="Build\dockerfiles\**" />
+    <Content Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <Content Remove="wwwroot\css\**" />
+    <Content Remove="wwwroot\vendor\jquery-nice-select\**" />
     <EmbeddedResource Remove="Build\dockerfiles\**" />
+    <EmbeddedResource Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <EmbeddedResource Remove="wwwroot\css\**" />
+    <EmbeddedResource Remove="wwwroot\vendor\jquery-nice-select\**" />
     <None Remove="Build\dockerfiles\**" />
+    <None Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <None Remove="wwwroot\css\**" />
+    <None Remove="wwwroot\vendor\jquery-nice-select\**" />
   </ItemGroup>
   <ItemGroup>
     <None Remove="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="bundleconfig.json" />
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Hangfire" Version="1.6.17" />
-    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.1" />
-    <PackageReference Include="Hangfire.PostgreSql" Version="1.4.8.1" />
+    <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" />
+    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.5.3" />
+    <PackageReference Include="HtmlSanitizer" Version="4.0.207" />
+    <PackageReference Include="LedgerWallet" Version="2.0.0.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
-    <PackageReference Include="NBitcoin" Version="4.0.0.38" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.9" />	  
-    <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.0.12" />
-    <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.1" />
-    <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.2" />
-    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.13" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.0.0" />
-    <PackageReference Include="System.ValueTuple" Version="4.4.0" />
-    <PackageReference Include="System.Xml.XmlSerializer" Version="4.0.11" />
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NBitcoin" Version="4.1.2.14" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
+    <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" />
+    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.18" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.2" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="2.1.2" />
+    <PackageReference Include="Serilog" Version="2.7.1" />
+    <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="Text.Analyzers" Version="2.6.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.0" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.0" PrivateAssets="All" />
-		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.0" PrivateAssets="All" />
+    <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>
 
 	<ItemGroup>
-		<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
-		<DotNetCliToolReference Include="Microsoft.Extensions.SecretManager.Tools" Version="2.0.0" />
 		<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0" />
 	</ItemGroup>
 
 	<ItemGroup>
-	  <None Include="wwwroot\img\bitcoin-symbol.svg" />
-	  <None Include="wwwroot\js\core.js" />
-	  <None Include="wwwroot\js\creative.js" />
-	  <None Include="wwwroot\js\creative.min.js" />
-	  <None Include="wwwroot\js\site.js" />
-	  <None Include="wwwroot\js\site.min.js" />
-	  <None Include="wwwroot\vendor\bootstrap\js\bootstrap.js" />
-	  <None Include="wwwroot\vendor\bootstrap\js\bootstrap.min.js" />
+	  <None Include="wwwroot\checkout\js\core.js" />
+	  <None Include="wwwroot\vendor\bootstrap4-creativestart\creative.js" />
 	  <None Include="wwwroot\vendor\font-awesome\fonts\fontawesome-webfont.svg" />
 	  <None Include="wwwroot\vendor\font-awesome\fonts\fontawesome-webfont.woff2" />
 	  <None Include="wwwroot\vendor\font-awesome\less\animated.less" />
@@ -99,5 +131,74 @@
 
 	<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>
-</Project>
+
+	<ItemGroup>
+    <Content Update="Views\Apps\_ViewImports.cshtml">
+      <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Home\BitpayTranslator.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Server\LightningChargeServices.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <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>
+    <Content Update="Views\Stores\ShowToken.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Stores\PayButtonEnable.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+	  <Content Update="Views\Stores\PayButton.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Public\PayButtonHandle.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Server\LndServices.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Server\Maintenance.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Server\Services.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\ListWallets.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\WalletRescan.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\WalletSendLedger.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\WalletTransactions.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\_Nav.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\_ViewImports.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\_ViewStart.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	</ItemGroup>
+</Project>

BTCPayServer/BTCPayServer.ruleset

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RuleSet Name="Microsoft Managed Recommended Rules" Description="These rules focus on the most critical problems in your code, including potential security holes, application crashes, and other important logic and design errors. It is recommended to include this rule set in any custom rule set you create for your projects." ToolsVersion="10.0">
+  <Localization ResourceAssembly="Microsoft.VisualStudio.CodeAnalysis.RuleSets.Strings.dll" ResourceBaseName="Microsoft.VisualStudio.CodeAnalysis.RuleSets.Strings.Localized">
+    <Name Resource="MinimumRecommendedRules_Name" />
+    <Description Resource="MinimumRecommendedRules_Description" />
+  </Localization>
+  <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
+    <Rule Id="CA1001" Action="Warning" />
+    <Rule Id="CA1009" Action="Warning" />
+    <Rule Id="CA1016" Action="Warning" />
+    <Rule Id="CA1033" Action="Warning" />
+    <Rule Id="CA1049" Action="Warning" />
+    <Rule Id="CA1060" Action="Warning" />
+    <Rule Id="CA1061" Action="Warning" />
+    <Rule Id="CA1063" Action="Warning" />
+    <Rule Id="CA1065" Action="Warning" />
+    <Rule Id="CA1301" Action="Warning" />
+    <Rule Id="CA1400" Action="Warning" />
+    <Rule Id="CA1401" Action="Warning" />
+    <Rule Id="CA1403" Action="Warning" />
+    <Rule Id="CA1404" Action="Warning" />
+    <Rule Id="CA1405" Action="Warning" />
+    <Rule Id="CA1410" Action="Warning" />
+    <Rule Id="CA1415" Action="Warning" />
+    <Rule Id="CA1821" Action="Warning" />
+    <Rule Id="CA1900" Action="Warning" />
+    <Rule Id="CA1901" Action="Warning" />
+    <Rule Id="CA2002" Action="Warning" />
+    <Rule Id="CA2100" Action="Warning" />
+    <Rule Id="CA2101" Action="Warning" />
+    <Rule Id="CA2108" Action="Warning" />
+    <Rule Id="CA2111" Action="Warning" />
+    <Rule Id="CA2112" Action="Warning" />
+    <Rule Id="CA2114" Action="Warning" />
+    <Rule Id="CA2116" Action="Warning" />
+    <Rule Id="CA2117" Action="Warning" />
+    <Rule Id="CA2122" Action="Warning" />
+    <Rule Id="CA2123" Action="Warning" />
+    <Rule Id="CA2124" Action="Warning" />
+    <Rule Id="CA2126" Action="Warning" />
+    <Rule Id="CA2131" Action="Warning" />
+    <Rule Id="CA2132" Action="Warning" />
+    <Rule Id="CA2133" Action="Warning" />
+    <Rule Id="CA2134" Action="Warning" />
+    <Rule Id="CA2137" Action="Warning" />
+    <Rule Id="CA2138" Action="Warning" />
+    <Rule Id="CA2140" Action="Warning" />
+    <Rule Id="CA2141" Action="Warning" />
+    <Rule Id="CA2146" Action="Warning" />
+    <Rule Id="CA2147" Action="Warning" />
+    <Rule Id="CA2149" Action="Warning" />
+    <Rule Id="CA2200" Action="Warning" />
+    <Rule Id="CA2202" Action="Warning" />
+    <Rule Id="CA2207" Action="Warning" />
+    <Rule Id="CA2212" Action="Warning" />
+    <Rule Id="CA2213" Action="Warning" />
+    <Rule Id="CA2214" Action="Warning" />
+    <Rule Id="CA2216" Action="Warning" />
+    <Rule Id="CA2220" Action="Warning" />
+    <Rule Id="CA2229" Action="Warning" />
+    <Rule Id="CA2231" Action="Warning" />
+    <Rule Id="CA2232" Action="Warning" />
+    <Rule Id="CA2235" Action="Warning" />
+    <Rule Id="CA2236" Action="Warning" />
+    <Rule Id="CA2237" Action="Warning" />
+    <Rule Id="CA2238" Action="Warning" />
+    <Rule Id="CA2240" Action="Warning" />
+    <Rule Id="CA2241" Action="Warning" />
+    <Rule Id="CA2242" Action="Warning" />
+  </Rules>
+  <Rules AnalyzerId="Microsoft.CodeAnalysis.CSharp.Analyzers" RuleNamespace="Microsoft.CodeAnalysis.CSharp.Analyzers" />
+</RuleSet>

BTCPayServer/BitpayHttpException.cs

@@ -4,15 +4,15 @@ using System.Text;
 
 namespace BTCPayServer
 {
-	public class BitpayHttpException : Exception
-	{
-		public BitpayHttpException(int code, string message) : base(message)
-		{
-			StatusCode = code;
-		}
-		public int StatusCode
-		{
-			get; set;
-		}
-	}
+    public class BitpayHttpException : Exception
+    {
+        public BitpayHttpException(int code, string message) : base(message)
+        {
+            StatusCode = code;
+        }
+        public int StatusCode
+        {
+            get; set;
+        }
+    }
 }

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -9,64 +9,276 @@ using System.Net;
 using System.Text;
 using StandardConfiguration;
 using Microsoft.Extensions.Configuration;
+using NBXplorer;
+using BTCPayServer.Payments.Lightning;
+using Renci.SshNet;
+using NBitcoin.DataEncoders;
+using BTCPayServer.SSH;
+using BTCPayServer.Lightning;
+using Serilog.Events;
 
 namespace BTCPayServer.Configuration
 {
-	public class BTCPayServerOptions
-	{
-		public Network Network
-		{
-			get; set;
-		}
-		public Uri Explorer
-		{
-			get; set;
-		}
+    public class NBXplorerConnectionSetting
+    {
+        public string CryptoCode { get; internal set; }
+        public Uri ExplorerUri { get; internal set; }
+        public string CookieFile { get; internal set; }
+    }
 
-		public string CookieFile
-		{
-			get; set;
-		}
-		public string ConfigurationFile
-		{
-			get;
-			private set;
-		}
-		public string DataDir
-		{
-			get;
-			private set;
-		}
-		public List<IPEndPoint> Listen
-		{
-			get;
-			set;
-		}
+    public class BTCPayServerOptions
+    {
+        public NetworkType NetworkType
+        {
+            get; set;
+        }
+        public string ConfigurationFile
+        {
+            get;
+            private set;
+        }
 
-		public void LoadArgs(IConfiguration conf)
-		{
-			var networkInfo = DefaultConfiguration.GetNetwork(conf);
-			Network = networkInfo?.Network;
-			if(Network == null)
-				throw new ConfigException("Invalid network");
+        public string LogFile
+        {
+            get;
+            private set;
+        }
+        public string DataDir
+        {
+            get;
+            private set;
+        }
+        public EndPoint SocksEndpoint { get; set; }
 
-			DataDir = conf.GetOrDefault<string>("datadir", networkInfo.DefaultDataDirectory);
-			Logs.Configuration.LogInformation("Network: " + Network);
+        public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
+        {
+            get;
+            set;
+        } = new List<NBXplorerConnectionSetting>();
 
-			Explorer = conf.GetOrDefault<Uri>("explorer.url", networkInfo.DefaultExplorerUrl);
-			CookieFile = conf.GetOrDefault<string>("explorer.cookiefile", networkInfo.DefaultExplorerCookieFile);
-			RequireHttps = conf.GetOrDefault<bool>("requirehttps", false);
-			PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
-		}
+        public bool DisableRegistration
+        {
+            get;
+            private set;
+        }
 
-		public bool RequireHttps
-		{
-			get; set;
-		}
-		public string PostgresConnectionString
-		{
-			get;
-			set;
-		}
-	}
+        public static string GetDebugLog(IConfiguration configuration)
+        {
+            return configuration.GetValue<string>("debuglog", null);
+        }
+        public static LogEventLevel GetDebugLogLevel(IConfiguration configuration)
+        {
+            var raw = configuration.GetValue("debugloglevel", nameof(LogEventLevel.Debug));
+            return (LogEventLevel)Enum.Parse(typeof(LogEventLevel), raw, true);
+        }
+
+        public void LoadArgs(IConfiguration conf)
+        {
+            NetworkType = DefaultConfiguration.GetNetworkType(conf);
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType);
+            DataDir = conf.GetOrDefault<string>("datadir", defaultSettings.DefaultDataDirectory);
+            Logs.Configuration.LogInformation("Network: " + NetworkType.ToString());
+
+            var supportedChains = conf.GetOrDefault<string>("chains", "btc")
+                                      .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                                      .Select(t => t.ToUpperInvariant());
+            NetworkProvider = new BTCPayNetworkProvider(NetworkType).Filter(supportedChains.ToArray());
+            foreach (var chain in supportedChains)
+            {
+                if (NetworkProvider.GetNetwork(chain) == null)
+                    throw new ConfigException($"Invalid chains \"{chain}\"");
+            }
+
+            var validChains = new List<string>();
+            foreach (var net in NetworkProvider.GetAll())
+            {
+                NBXplorerConnectionSetting setting = new NBXplorerConnectionSetting();
+                setting.CryptoCode = net.CryptoCode;
+                setting.ExplorerUri = conf.GetOrDefault<Uri>($"{net.CryptoCode}.explorer.url", net.NBXplorerNetwork.DefaultSettings.DefaultUrl);
+                setting.CookieFile = conf.GetOrDefault<string>($"{net.CryptoCode}.explorer.cookiefile", net.NBXplorerNetwork.DefaultSettings.DefaultCookieFile);
+                NBXplorerConnectionSettings.Add(setting);
+
+                {
+                    var lightning = conf.GetOrDefault<string>($"{net.CryptoCode}.lightning", string.Empty);
+                    if (lightning.Length != 0)
+                    {
+                        if (!LightningConnectionString.TryParse(lightning, true, out var connectionString, out var error))
+                        {
+                            Logs.Configuration.LogWarning($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
+                                $"If you have a c-lightning server use: 'type=clightning;server=/root/.lightning/lightning-rpc', " + Environment.NewLine +
+                                $"If you have a lightning charge server: 'type=charge;server=https://charge.example.com;api-token=yourapitoken'" + Environment.NewLine +
+                                $"If you have a lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                $"              lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                $"Error: {error}" + Environment.NewLine +
+                                "This service will not be exposed through BTCPay Server");
+                        }
+                        else
+                        {
+                            if (connectionString.IsLegacy)
+                            {
+                                Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning is a deprecated format, it will work now, but please replace it for future versions with '{connectionString.ToString()}'");
+                            }
+                            InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
+                        }
+                    }
+                }
+
+                ExternalServices.Load(net.CryptoCode, conf);
+            }
+
+            Logs.Configuration.LogInformation("Supported chains: " + String.Join(',', supportedChains.ToArray()));
+
+            var services = conf.GetOrDefault<string>("externalservices", null);
+            if (services != null)
+            {
+                foreach (var service in services.Split(new[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries)
+                                                .Select(p => (p, SeparatorIndex: p.IndexOf(':', StringComparison.OrdinalIgnoreCase)))
+                                                .Where(p => p.SeparatorIndex != -1)
+                                                .Select(p => (Name: p.p.Substring(0, p.SeparatorIndex), 
+                                                              Link: p.p.Substring(p.SeparatorIndex + 1))))
+                {
+                    if (Uri.TryCreate(service.Link, UriKind.RelativeOrAbsolute, out var uri))
+                        OtherExternalServices.AddOrReplace(service.Name, uri);
+                }
+            }
+
+            PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
+            MySQLConnectionString = conf.GetOrDefault<string>("mysql", null);
+            BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
+            TorrcFile = conf.GetOrDefault<string>("torrcfile", null);
+
+            var socksEndpointString = conf.GetOrDefault<string>("socksendpoint", null);
+            if(!string.IsNullOrEmpty(socksEndpointString))
+            {
+                if (!Utils.TryParseEndpoint(socksEndpointString, 9050, out var endpoint))
+                    throw new ConfigException("Invalid value for socksendpoint");
+                SocksEndpoint = endpoint;
+            }
+            
+
+            var sshSettings = ParseSSHConfiguration(conf);
+            if ((!string.IsNullOrEmpty(sshSettings.Password) || !string.IsNullOrEmpty(sshSettings.KeyFile)) && !string.IsNullOrEmpty(sshSettings.Server))
+            {
+                int waitTime = 0;
+                while (!string.IsNullOrEmpty(sshSettings.KeyFile) && !File.Exists(sshSettings.KeyFile))
+                {
+                    if (waitTime++ < 5)
+                        System.Threading.Thread.Sleep(1000);
+                    else
+                        throw new ConfigException($"sshkeyfile does not exist");
+                }
+
+                if (sshSettings.Port > ushort.MaxValue ||
+                   sshSettings.Port < ushort.MinValue)
+                    throw new ConfigException($"ssh port is invalid");
+                if (!string.IsNullOrEmpty(sshSettings.Password) && !string.IsNullOrEmpty(sshSettings.KeyFile))
+                    throw new ConfigException($"sshpassword or sshkeyfile should be provided, but not both");
+                try
+                {
+                    sshSettings.CreateConnectionInfo();
+                }
+                catch
+                {
+                    throw new ConfigException($"sshkeyfilepassword is invalid");
+                }
+                SSHSettings = sshSettings;
+            }
+
+            var fingerPrints = conf.GetOrDefault<string>("sshtrustedfingerprints", "");
+            if (!string.IsNullOrEmpty(fingerPrints))
+            {
+                foreach (var fingerprint in fingerPrints.Split(';', StringSplitOptions.RemoveEmptyEntries))
+                {
+                    if (!SSHFingerprint.TryParse(fingerprint, out var f))
+                        throw new ConfigException($"Invalid ssh fingerprint format {fingerprint}");
+                    TrustedFingerprints.Add(f);
+                }
+            }
+
+            RootPath = conf.GetOrDefault<string>("rootpath", "/");
+            if (!RootPath.StartsWith("/", StringComparison.InvariantCultureIgnoreCase))
+                RootPath = "/" + RootPath;
+            var old = conf.GetOrDefault<Uri>("internallightningnode", null);
+            if (old != null)
+                throw new ConfigException($"internallightningnode is deprecated and should not be used anymore, use btclightning instead");
+
+            LogFile = GetDebugLog(conf);
+            if (!string.IsNullOrEmpty(LogFile))
+            {
+                Logs.Configuration.LogInformation("LogFile: " + LogFile);
+                Logs.Configuration.LogInformation("Log Level: " + GetDebugLogLevel(conf));
+            }
+
+            DisableRegistration = conf.GetOrDefault<bool>("disable-registration", true);
+        }
+
+        private SSHSettings ParseSSHConfiguration(IConfiguration conf)
+        {
+            var settings = new SSHSettings();
+            settings.Server = conf.GetOrDefault<string>("sshconnection", null);
+            if (settings.Server != null)
+            {
+                var parts = settings.Server.Split(':');
+                if (parts.Length == 2 && int.TryParse(parts[1], out int port))
+                {
+                    settings.Port = port;
+                    settings.Server = parts[0];
+                }
+                else
+                {
+                    settings.Port = 22;
+                }
+
+                parts = settings.Server.Split('@');
+                if (parts.Length == 2)
+                {
+                    settings.Username = parts[0];
+                    settings.Server = parts[1];
+                }
+                else
+                {
+                    settings.Username = "root";
+                }
+            }
+            settings.Password = conf.GetOrDefault<string>("sshpassword", "");
+            settings.KeyFile = conf.GetOrDefault<string>("sshkeyfile", "");
+            settings.KeyFilePassword = conf.GetOrDefault<string>("sshkeyfilepassword", "");
+            return settings;
+        }
+
+        internal bool IsTrustedFingerprint(byte[] fingerPrint, byte[] hostKey)
+        {
+            return TrustedFingerprints.Any(f => f.Match(fingerPrint, hostKey));
+        }
+
+        public string RootPath { get; set; }
+        public Dictionary<string, LightningConnectionString> InternalLightningByCryptoCode { get; set; } = new Dictionary<string, LightningConnectionString>();
+
+        public Dictionary<string, Uri> OtherExternalServices { get; set; } = new Dictionary<string, Uri>();
+        public ExternalServices ExternalServices { get; set; } = new ExternalServices();
+
+        public BTCPayNetworkProvider NetworkProvider { get; set; }
+        public string PostgresConnectionString
+        {
+            get;
+            set;
+        }
+        public string MySQLConnectionString
+        {
+            get;
+            set;
+        }
+        public bool BundleJsCss
+        {
+            get;
+            set;
+        }
+        public List<SSHFingerprint> TrustedFingerprints { get; set; } = new List<SSHFingerprint>();
+        public SSHSettings SSHSettings
+        {
+            get;
+            set;
+        }
+        public string TorrcFile { get; set; }
+    }
 }

BTCPayServer/Configuration/BTCPayServerRuntime.cs

@@ -1,128 +0,0 @@
-using BTCPayServer.Authentication;
-using Microsoft.Extensions.Logging;
-using BTCPayServer.Logging;
-using DBreeze;
-using NBitcoin;
-using NBXplorer;
-using NBXplorer.DerivationStrategy;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.EntityFrameworkCore;
-using BTCPayServer.Data;
-using BTCPayServer.Servcices.Invoices;
-using BTCPayServer.Services.Wallets;
-
-namespace BTCPayServer.Configuration
-{
-	public class BTCPayServerRuntime : IDisposable
-	{
-		public ExplorerClient Explorer
-		{
-			get;
-			private set;
-		}
-
-		public void Configure(BTCPayServerOptions opts)
-		{
-			ConfigureAsync(opts).GetAwaiter().GetResult();
-		}
-		public async Task ConfigureAsync(BTCPayServerOptions opts)
-		{
-			Network = opts.Network;
-			Explorer = new ExplorerClient(opts.Network, opts.Explorer);
-
-			if(!Explorer.SetCookieAuth(opts.CookieFile))
-				Explorer.SetNoAuth();
-
-			CancellationTokenSource cts = new CancellationTokenSource(10000);
-			try
-			{
-				Logs.Configuration.LogInformation("Trying to connect to explorer " + Explorer.Address.AbsoluteUri);
-				await Explorer.WaitServerStartedAsync(cts.Token).ConfigureAwait(false);
-				Logs.Configuration.LogInformation("Connection successfull");
-			}
-			catch(Exception ex)
-			{
-				throw new ConfigException($"Could not connect to NBXplorer, {ex.Message}");
-			}
-			DBreezeEngine db = new DBreezeEngine(CreateDBPath(opts, "TokensDB"));
-			_Resources.Add(db);
-			TokenRepository = new TokenRepository(db);
-
-			db = new DBreezeEngine(CreateDBPath(opts, "InvoiceDB"));
-			_Resources.Add(db);
-
-			ApplicationDbContextFactory dbContext = null;
-			if(opts.PostgresConnectionString == null)
-			{
-				var connStr = "Data Source=" + Path.Combine(opts.DataDir, "sqllite.db");
-				Logs.Configuration.LogInformation($"SQLite DB used ({connStr})");
-				dbContext = new ApplicationDbContextFactory(DatabaseType.Sqlite, connStr);
-			}
-			else
-			{
-				Logs.Configuration.LogInformation($"Postgres DB used ({opts.PostgresConnectionString})");
-				dbContext = new ApplicationDbContextFactory(DatabaseType.Postgres, opts.PostgresConnectionString);
-			}
-			DBFactory = dbContext;
-			InvoiceRepository = new InvoiceRepository(dbContext, db, Network);
-
-
-			db = new DBreezeEngine(CreateDBPath(opts, "AddressMapping"));
-			_Resources.Add(db);
-			Wallet = new BTCPayWallet(Explorer, db);
-		}
-
-		private static string CreateDBPath(BTCPayServerOptions opts, string name)
-		{
-			var dbpath = Path.Combine(opts.DataDir, name);
-			if(!Directory.Exists(dbpath))
-				Directory.CreateDirectory(dbpath);
-			return dbpath;
-		}
-
-		List<IDisposable> _Resources = new List<IDisposable>();
-
-		public void Dispose()
-		{
-			lock(_Resources)
-			{
-				foreach(var r in _Resources)
-				{
-					r.Dispose();
-				}
-				_Resources.Clear();
-			}
-		}
-
-		public Network Network
-		{
-			get;
-			private set;
-		}
-		public TokenRepository TokenRepository
-		{
-			get; set;
-		}
-		public InvoiceRepository InvoiceRepository
-		{
-			get;
-			set;
-		}
-		public BTCPayWallet Wallet
-		{
-			get;
-			set;
-		}
-		public ApplicationDbContextFactory DBFactory
-		{
-			get;
-			set;
-		}
-	}
-
-}

BTCPayServer/Configuration/ConfigException.cs

@@ -5,11 +5,11 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Configuration
 {
-	public class ConfigException : Exception
-	{
-		public ConfigException(string message) : base(message)
-		{
+    public class ConfigException : Exception
+    {
+        public ConfigException(string message) : base(message)
+        {
 
-		}
-	}
+        }
+    }
 }

BTCPayServer/Configuration/ConfigurationExtensions.cs

@@ -6,47 +6,57 @@ using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Primitives;
+using NBitcoin;
 
 namespace BTCPayServer.Configuration
 {
-	public static class ConfigurationExtensions
-	{
-		public static T GetOrDefault<T>(this IConfiguration configuration, string key, T defaultValue)
-		{
-			var str = configuration[key] ?? configuration[key.Replace(".", string.Empty)];
-			if(str == null)
-				return defaultValue;
-			if(typeof(T) == typeof(bool))
-			{
-				var trueValues = new[] { "1", "true" };
-				var falseValues = new[] { "0", "false" };
-				if(trueValues.Contains(str, StringComparer.OrdinalIgnoreCase))
-					return (T)(object)true;
-				if(falseValues.Contains(str, StringComparer.OrdinalIgnoreCase))
-					return (T)(object)false;
-				throw new FormatException();
-			}
-			else if(typeof(T) == typeof(Uri))
-				return (T)(object)new Uri(str, UriKind.Absolute);
-			else if(typeof(T) == typeof(string))
-				return (T)(object)str;
-			else if(typeof(T) == typeof(IPEndPoint))
-			{
-				var separator = str.LastIndexOf(":");
-				if(separator == -1)
-					throw new FormatException();
-				var ip = str.Substring(0, separator);
-				var port = str.Substring(separator + 1);
-				return (T)(object)new IPEndPoint(IPAddress.Parse(ip), int.Parse(port));
-			}
-			else if(typeof(T) == typeof(int))
-			{
-				return (T)(object)int.Parse(str, CultureInfo.InvariantCulture);
-			}
-			else
-			{
-				throw new NotSupportedException("Configuration value does not support time " + typeof(T).Name);
-			}
-		}
-	}
+    public static class ConfigurationExtensions
+    {
+        public static T GetOrDefault<T>(this IConfiguration configuration, string key, T defaultValue)
+        {
+            var str = configuration[key] ?? configuration[key.Replace(".", string.Empty, StringComparison.InvariantCulture)];
+            if (str == null)
+                return defaultValue;
+            if (typeof(T) == typeof(bool))
+            {
+                var trueValues = new[] { "1", "true" };
+                var falseValues = new[] { "0", "false" };
+                if (trueValues.Contains(str, StringComparer.OrdinalIgnoreCase))
+                    return (T)(object)true;
+                if (falseValues.Contains(str, StringComparer.OrdinalIgnoreCase))
+                    return (T)(object)false;
+                throw new FormatException();
+            }
+            else if (typeof(T) == typeof(Uri))
+                if (string.IsNullOrEmpty(str))
+                {
+                    return defaultValue;
+                }
+                else
+                {
+                    return (T)(object)new Uri(str, UriKind.Absolute);
+                }
+            else if (typeof(T) == typeof(string))
+                return (T)(object)str;
+            else if (typeof(T) == typeof(IPAddress))
+                return (T)(object)IPAddress.Parse(str);
+            else if (typeof(T) == typeof(IPEndPoint))
+            {
+                var separator = str.LastIndexOf(":", StringComparison.InvariantCulture);
+                if (separator == -1)
+                    throw new FormatException();
+                var ip = str.Substring(0, separator);
+                var port = str.Substring(separator + 1);
+                return (T)(object)new IPEndPoint(IPAddress.Parse(ip), int.Parse(port, CultureInfo.InvariantCulture));
+            }
+            else if (typeof(T) == typeof(int))
+            {
+                return (T)(object)int.Parse(str, CultureInfo.InvariantCulture);
+            }
+            else
+            {
+                throw new NotSupportedException("Configuration value does not support time " + typeof(T).Name);
+            }
+        }
+    }
 }

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -10,91 +10,131 @@ using System.Threading.Tasks;
 using NBitcoin;
 using System.Text;
 using CommandLine;
+using NBXplorer;
 
 namespace BTCPayServer.Configuration
 {
-	public class DefaultConfiguration : StandardConfiguration.DefaultConfiguration
-	{
-		protected override CommandLineApplication CreateCommandLineApplicationCore()
-		{
-			CommandLineApplication app = new CommandLineApplication(true)
-			{
-				FullName = "NBXplorer\r\nLightweight block explorer for tracking HD wallets",
-				Name = "NBXplorer"
-			};
-			app.HelpOption("-? | -h | --help");
-			app.Option("-n | --network", $"Set the network among ({NetworkInformation.ToStringAll()}) (default: {Network.Main.ToString()})", CommandOptionType.SingleValue);
-			app.Option("--testnet | -testnet", $"Use testnet", CommandOptionType.BoolValue);
-			app.Option("--regtest | -regtest", $"Use regtest", CommandOptionType.BoolValue);
-			app.Option("--requirehttps", $"Will redirect to https version of the website (default: false)", CommandOptionType.BoolValue);
-			app.Option("--postgres", $"Connection string to postgres database (default: sqlite is used)", CommandOptionType.SingleValue);
-			app.Option("--explorerurl", $"Url of the NBxplorer (default: : Default setting of NBXplorer for the network)", CommandOptionType.SingleValue);
-			app.Option("--explorercookiefile", $"Path to the cookie file (default: Default setting of NBXplorer for the network)", CommandOptionType.SingleValue);
+    public class DefaultConfiguration : StandardConfiguration.DefaultConfiguration
+    {
+        protected override CommandLineApplication CreateCommandLineApplicationCore()
+        {
+            var provider = new BTCPayNetworkProvider(NetworkType.Mainnet);
+            var chains = string.Join(",", provider.GetAll().Select(n => n.CryptoCode.ToLowerInvariant()).ToArray());
+            CommandLineApplication app = new CommandLineApplication(true)
+            {
+                FullName = "BTCPay\r\nOpen source, self-hosted payment processor.",
+                Name = "BTCPay"
+            };
+            app.HelpOption("-? | -h | --help");
+            app.Option("-n | --network", $"Set the network among (mainnet,testnet,regtest) (default: mainnet)", CommandOptionType.SingleValue);
+            app.Option("--testnet | -testnet", $"Use testnet (deprecated, use --network instead)", CommandOptionType.BoolValue);
+            app.Option("--regtest | -regtest", $"Use regtest (deprecated, use --network instead)", CommandOptionType.BoolValue);
+            app.Option("--chains | -c", $"Chains to support as a comma separated (default: btc; available: {chains})", CommandOptionType.SingleValue);
+            app.Option("--postgres", $"Connection string to a PostgreSQL database (default: SQLite)", CommandOptionType.SingleValue);
+            app.Option("--mysql", $"Connection string to a MySQL database (default: SQLite)", CommandOptionType.SingleValue);
+            app.Option("--externalservices", $"Links added to external services inside Server Settings / Services under the format service1:path2;service2:path2.(default: empty)", CommandOptionType.SingleValue);
+            app.Option("--bundlejscss", $"Bundle JavaScript and CSS files for better performance (default: true)", CommandOptionType.SingleValue);
+            app.Option("--rootpath", "The root path in the URL to access BTCPay (default: /)", CommandOptionType.SingleValue);
+            app.Option("--sshconnection", "SSH server to manage BTCPay under the form user@server:port (default: root@externalhost or empty)", CommandOptionType.SingleValue);
+            app.Option("--sshpassword", "SSH password to manage BTCPay (default: empty)", CommandOptionType.SingleValue);
+            app.Option("--sshkeyfile", "SSH private key file to manage BTCPay (default: empty)", CommandOptionType.SingleValue);
+            app.Option("--sshkeyfilepassword", "Password of the SSH keyfile (default: empty)", CommandOptionType.SingleValue);
+            app.Option("--sshtrustedfingerprints", "SSH Host public key fingerprint or sha256 (default: empty, it will allow untrusted connections)", CommandOptionType.SingleValue);
+            app.Option("--torrcfile", "Path to torrc file containing hidden services directories (default: empty)", CommandOptionType.SingleValue);
+            app.Option("--socksendpoint", "Socks endpoint to connect to onion urls (default: empty)", CommandOptionType.SingleValue);
+            app.Option("--debuglog", "A rolling log file for debug messages.", CommandOptionType.SingleValue);
+            app.Option("--debugloglevel", "The severity you log (default:information)", CommandOptionType.SingleValue);
+            app.Option("--disable-registration", "Disables new user registrations (default:true)", CommandOptionType.SingleValue);
+            foreach (var network in provider.GetAll())
+            {
+                var crypto = network.CryptoCode.ToLowerInvariant();
+                app.Option($"--{crypto}explorerurl", $"URL of the NBXplorer for {network.CryptoCode} (default: {network.NBXplorerNetwork.DefaultSettings.DefaultUrl})", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}explorercookiefile", $"Path to the cookie file (default: {network.NBXplorerNetwork.DefaultSettings.DefaultCookieFile})", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}lightning", $"Easy configuration of lightning for the server administrator: Must be a UNIX socket of c-lightning (lightning-rpc) or URL to a charge server (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externallndgrpc", $"The LND gRPC configuration BTCPay will expose to easily connect to the internal lnd wallet from Zap wallet (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externalspark", $"Show spark information in Server settings / Server. The connection string to spark server (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externalcharge", $"Show lightning charge information in Server settings/Server. The connection string to charge server (default: empty)", CommandOptionType.SingleValue);
+            }
+            return app;
+        }
 
-			return app;
-		}
+        public override string EnvironmentVariablePrefix => "BTCPAY_";
 
-		public override string EnvironmentVariablePrefix => "BTCPAY_";
+        protected override string GetDefaultDataDir(IConfiguration conf)
+        {
+            return BTCPayDefaultSettings.GetDefaultSettings(GetNetworkType(conf)).DefaultDataDirectory;
+        }
 
-		protected override string GetDefaultDataDir(IConfiguration conf)
-		{
-			return GetNetwork(conf).DefaultDataDirectory;
-		}
+        protected override string GetDefaultConfigurationFile(IConfiguration conf)
+        {
+            var network = BTCPayDefaultSettings.GetDefaultSettings(GetNetworkType(conf));
+            var dataDir = conf["datadir"];
+            if (dataDir == null)
+                return network.DefaultConfigurationFile;
+            var fileName = Path.GetFileName(network.DefaultConfigurationFile);
+            var chainDir = Path.GetFileName(Path.GetDirectoryName(network.DefaultConfigurationFile));
+            chainDir = Path.Combine(dataDir, chainDir);
+            try
+            {
+                if (!Directory.Exists(chainDir))
+                    Directory.CreateDirectory(chainDir);
+            }
+            catch { }
+            return Path.Combine(chainDir, fileName);
+        }
 
-		protected override string GetDefaultConfigurationFile(IConfiguration conf)
-		{
-			var network = GetNetwork(conf);
-			var dataDir = conf["datadir"];
-			if(dataDir == null)
-				return network.DefaultConfigurationFile;
-			var fileName = Path.GetFileName(network.DefaultConfigurationFile);
-			return Path.Combine(dataDir, fileName);
-		}
+        public static NetworkType GetNetworkType(IConfiguration conf)
+        {
+            var network = conf.GetOrDefault<string>("network", null);
+            if (network != null)
+            {
+                var n = Network.GetNetwork(network);
+                if (n == null)
+                {
+                    throw new ConfigException($"Invalid network parameter '{network}'");
+                }
+                return n.NetworkType;
+            }
+            var net = conf.GetOrDefault<bool>("regtest", false) ? NetworkType.Regtest :
+                        conf.GetOrDefault<bool>("testnet", false) ? NetworkType.Testnet : NetworkType.Mainnet;
 
-		public static NetworkInformation GetNetwork(IConfiguration conf)
-		{
-			var network = conf.GetOrDefault<string>("network", null);
-			if(network != null)
-			{
-				var info = NetworkInformation.GetNetworkByName(network);
-				if(info == null)
-					throw new ConfigException($"Invalid network name {network}");
-				return info;
-			}
+            return net;
+        }
 
-			var net = conf.GetOrDefault<bool>("regtest", false) ? Network.RegTest :
-						conf.GetOrDefault<bool>("testnet", false) ? Network.TestNet : Network.Main;
-
-			return NetworkInformation.GetNetworkByName(net.Name);
-		}
-
-		protected override string GetDefaultConfigurationFileTemplate(IConfiguration conf)
-		{
-			var network = GetNetwork(conf);
-			StringBuilder builder = new StringBuilder();
-			builder.AppendLine("### Global settings ###");
-			builder.AppendLine("#testnet=0");
-			builder.AppendLine("#regtest=0");
-			builder.AppendLine();
-			builder.AppendLine("### Server settings ###");
-			builder.AppendLine("#requirehttps=0");
-			builder.AppendLine("#port=" + network.DefaultPort);
-			builder.AppendLine("#bind=127.0.0.1");
-			builder.AppendLine();
-			builder.AppendLine("### Database ###");
-			builder.AppendLine("#postgres=User ID=root;Password=myPassword;Host=localhost;Port=5432;Database=myDataBase;");
-			builder.AppendLine();
-			builder.AppendLine("### NBXplorer settings ###");
-			builder.AppendLine("#explorer.url=" + network.DefaultExplorerUrl.AbsoluteUri);
-			builder.AppendLine("#explorer.cookiefile=" + network.DefaultExplorerCookieFile);
-			return builder.ToString();
-		}
+        protected override string GetDefaultConfigurationFileTemplate(IConfiguration conf)
+        {
+            var networkType = GetNetworkType(conf);
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(networkType);
+            StringBuilder builder = new StringBuilder();
+            builder.AppendLine("### Global settings ###");
+            builder.AppendLine("#network=mainnet");
+            builder.AppendLine();
+            builder.AppendLine("### Server settings ###");
+            builder.AppendLine("#port=" + defaultSettings.DefaultPort);
+            builder.AppendLine("#bind=127.0.0.1");
+            builder.AppendLine("#httpscertificatefilepath=devtest.pfx");
+            builder.AppendLine("#httpscertificatefilepassword=toto");
+            builder.AppendLine();
+            builder.AppendLine("### Database ###");
+            builder.AppendLine("#postgres=User ID=root;Password=myPassword;Host=localhost;Port=5432;Database=myDataBase;");
+            builder.AppendLine("#mysql=User ID=root;Password=myPassword;Host=localhost;Port=3306;Database=myDataBase;");
+            builder.AppendLine();
+            builder.AppendLine("### NBXplorer settings ###");
+            foreach (var n in new BTCPayNetworkProvider(networkType).GetAll())
+            {
+                builder.AppendLine($"#{n.CryptoCode}.explorer.url={n.NBXplorerNetwork.DefaultSettings.DefaultUrl}");
+                builder.AppendLine($"#{n.CryptoCode}.explorer.cookiefile={ n.NBXplorerNetwork.DefaultSettings.DefaultCookieFile}");
+                builder.AppendLine($"#{n.CryptoCode}.lightning=/root/.lightning/lightning-rpc");
+                builder.AppendLine($"#{n.CryptoCode}.lightning=https://apitoken:API_TOKEN_SECRET@charge.example.com/");
+            }
+            return builder.ToString();
+        }
 
 
 
-		protected override IPEndPoint GetDefaultEndpoint(IConfiguration conf)
-		{
-			return new IPEndPoint(IPAddress.Parse("127.0.0.1"), GetNetwork(conf).DefaultPort);
-		}
-	}
+        protected override IPEndPoint GetDefaultEndpoint(IConfiguration conf)
+        {
+            return new IPEndPoint(IPAddress.Parse("127.0.0.1"), BTCPayDefaultSettings.GetDefaultSettings(GetNetworkType(conf)).DefaultPort);
+        }
+    }
 }

BTCPayServer/Configuration/ExternalConnectionString.cs

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

BTCPayServer/Configuration/ExternalService.cs

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

BTCPayServer/Configuration/NetworkInformation.cs

@@ -1,103 +0,0 @@
-using Microsoft.Extensions.Configuration;
-using NBitcoin;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Configuration
-{
-	public class NetworkInformation
-	{
-		static NetworkInformation()
-		{
-			_Networks = new Dictionary<string, NetworkInformation>();
-			foreach(var network in Network.GetNetworks())
-			{
-				NetworkInformation info = new NetworkInformation();
-				info.DefaultDataDirectory = StandardConfiguration.DefaultDataDirectory.GetDirectory("BTCPayServer", network.Name);
-				info.DefaultConfigurationFile = Path.Combine(info.DefaultDataDirectory, "settings.config");
-				info.DefaultExplorerCookieFile = Path.Combine(StandardConfiguration.DefaultDataDirectory.GetDirectory("NBXplorer", network.Name, false), ".cookie");
-				info.Network = network;
-				info.DefaultExplorerUrl = new Uri("http://127.0.0.1:24446", UriKind.Absolute);
-				info.DefaultPort = 23002;
-				_Networks.Add(network.Name, info);
-				if(network == Network.Main)
-				{
-					info.DefaultExplorerUrl = new Uri("http://127.0.0.1:24444", UriKind.Absolute);
-					Main = info;
-					info.DefaultPort = 23000;
-				}
-				if(network == Network.TestNet)
-				{
-					info.DefaultExplorerUrl = new Uri("http://127.0.0.1:24445", UriKind.Absolute);
-					info.DefaultPort = 23001;
-				}
-			}
-		}
-
-		static Dictionary<string, NetworkInformation> _Networks;
-		public static NetworkInformation GetNetworkByName(string name)
-		{
-			var value = _Networks.TryGet(name);
-			if(value != null)
-				return value;
-
-			//Maybe alias ?
-			var network = Network.GetNetwork(name);
-			if(network != null)
-			{
-				value = _Networks.TryGet(network.Name);
-				if(value != null)
-					return value;
-			}
-			return null;
-		}
-
-		public static NetworkInformation Main
-		{
-			get;
-			set;
-		}
-		public Network Network
-		{
-			get; set;
-		}
-		public string DefaultConfigurationFile
-		{
-			get;
-			set;
-		}
-		public string DefaultDataDirectory
-		{
-			get;
-			set;
-		}
-		public Uri DefaultExplorerUrl
-		{
-			get;
-			internal set;
-		}
-		public int DefaultPort
-		{
-			get;
-			private set;
-		}
-		public string DefaultExplorerCookieFile
-		{
-			get;
-			internal set;
-		}
-
-		public override string ToString()
-		{
-			return Network.ToString();
-		}
-
-		public static string ToStringAll()
-		{
-			return string.Join(", ", _Networks.Select(n => n.Key).ToArray());
-		}
-	}
-}

BTCPayServer/Controllers/AccessTokenController.cs

@@ -2,6 +2,7 @@
 using BTCPayServer.Filters;
 using BTCPayServer.Models;
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin.DataEncoders;
 using NBitpayClient;
@@ -12,51 +13,82 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Controllers
 {
-	public class AccessTokenController : Controller
-	{
-		TokenRepository _TokenRepository;
-		public AccessTokenController(TokenRepository tokenRepository)
-		{
-			_TokenRepository = tokenRepository ?? throw new ArgumentNullException(nameof(tokenRepository));
-		}
-		[HttpGet]
-		[Route("tokens")]
-		public async Task<GetTokensResponse> GetTokens()
-		{
-			var tokens = await _TokenRepository.GetTokens(this.GetBitIdentity().SIN);
-			return new GetTokensResponse(tokens);
-		}
+    [Authorize(AuthenticationSchemes = Security.Policies.BitpayAuthentication)]
+    [BitpayAPIConstraint()]
+    public class AccessTokenController : Controller
+    {
+        TokenRepository _TokenRepository;
+        public AccessTokenController(TokenRepository tokenRepository)
+        {
+            _TokenRepository = tokenRepository ?? throw new ArgumentNullException(nameof(tokenRepository));
+        }
+        [HttpGet]
+        [Route("tokens")]
+        public async Task<GetTokensResponse> Tokens()
+        {
+            var tokens = await _TokenRepository.GetTokens(this.User.GetSIN());
+            return new GetTokensResponse(tokens);
+        }
 
-		[HttpPost]
-		[Route("tokens")]
-		public async Task<DataWrapper<List<PairingCodeResponse>>> GetPairingCode([FromBody] PairingCodeRequest token)
-		{
-			var now = DateTimeOffset.UtcNow;
-			var pairingEntity = new PairingCodeEntity()
-			{
-				Facade = token.Facade,
-				Label = token.Label,
-				SIN = token.Id,
-				PairingTime = now,
-				PairingExpiration = now + TimeSpan.FromMinutes(15)
-			};
-			var grantedToken = await _TokenRepository.CreateToken(token.Id, token.Facade);
-			pairingEntity.Token = grantedToken.Name;
-			pairingEntity = await _TokenRepository.AddPairingCodeAsync(pairingEntity);
+        [HttpPost]
+        [Route("tokens")]
+        [AllowAnonymous]
+        public async Task<DataWrapper<List<PairingCodeResponse>>> Tokens([FromBody] TokenRequest request)
+        {
+            if (request == null)
+                throw new BitpayHttpException(400, "The request body is missing");
+            PairingCodeEntity pairingEntity = null;
+            if (string.IsNullOrEmpty(request.PairingCode))
+            {
+                if (string.IsNullOrEmpty(request.Id) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(request.Id))
+                    throw new BitpayHttpException(400, "'id' property is required");
 
-			var pairingCodes = new List<PairingCodeResponse>
-			{
-				new PairingCodeResponse()
-				{
-					PairingCode = pairingEntity.Id,
-					PairingExpiration = pairingEntity.PairingExpiration,
-					DateCreated = pairingEntity.PairingTime,
-					Facade = grantedToken.Name,
-					Token = grantedToken.Value,
-					Label = pairingEntity.Label
-				}
-			};
-			return DataWrapper.Create(pairingCodes);
-		}
-	}
+                var pairingCode = await _TokenRepository.CreatePairingCodeAsync();
+                await _TokenRepository.PairWithSINAsync(pairingCode, request.Id);
+                pairingEntity = await _TokenRepository.UpdatePairingCode(new PairingCodeEntity()
+                {
+                    Id = pairingCode,
+                    Label = request.Label
+                });
+
+            }
+            else
+            {
+                var sin = this.User.GetSIN() ?? request.Id;
+                if (string.IsNullOrEmpty(sin) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(sin))
+                    throw new BitpayHttpException(400, "'id' property is required, alternatively, use BitId");
+
+                pairingEntity = await _TokenRepository.GetPairingAsync(request.PairingCode);
+                if (pairingEntity == null)
+                    throw new BitpayHttpException(404, "The specified pairingCode is not found");
+                pairingEntity.SIN = sin;
+
+                if (string.IsNullOrEmpty(pairingEntity.Label) && !string.IsNullOrEmpty(request.Label))
+                {
+                    pairingEntity.Label = request.Label;
+                    await _TokenRepository.UpdatePairingCode(pairingEntity);
+                }
+
+                var result = await _TokenRepository.PairWithSINAsync(request.PairingCode, sin);
+                if (result != PairingResult.Complete && result != PairingResult.Partial)
+                    throw new BitpayHttpException(400, $"Error while pairing ({result})");
+
+            }
+
+            var pairingCodes = new List<PairingCodeResponse>
+                {
+                    new PairingCodeResponse()
+                    {
+                        Policies = new Newtonsoft.Json.Linq.JArray(),
+                        PairingCode = pairingEntity.Id,
+                        PairingExpiration = pairingEntity.Expiration,
+                        DateCreated = pairingEntity.CreatedTime,
+                        Facade = "merchant",
+                        Token = pairingEntity.TokenValue,
+                        Label = pairingEntity.Label
+                    }
+                };
+            return DataWrapper.Create(pairingCodes);
+        }
+    }
 }

BTCPayServer/Controllers/AppsController.Crowdfund.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Linq;
+using System.Text;
+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
+{
+    public partial class AppsController
+    {
+        public class AppUpdated
+        {
+            public string AppId { get; set; }
+            public object Settings { get; set; }
+            public string StoreId { get; set; }
+            public override string ToString()
+            {
+                return String.Empty;
+            }
+        }
+        
+        
+        [HttpGet]
+        [Route("{appId}/settings/crowdfund")]
+        public async Task<IActionResult> UpdateCrowdfund(string appId)
+        {
+            var app = await GetOwnedApp(appId, AppType.Crowdfund);
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<CrowdfundSettings>();
+            var vm = new UpdateCrowdfundViewModel()
+            {
+                NotificationEmailWarning = !await IsEmailConfigured(app.StoreDataId),
+                Title = settings.Title,
+                Enabled = settings.Enabled,
+                EnforceTargetAmount = settings.EnforceTargetAmount,
+                StartDate = settings.StartDate,
+                TargetCurrency = settings.TargetCurrency,
+                Description = settings.Description,
+                MainImageUrl = settings.MainImageUrl,
+                EmbeddedCSS = settings.EmbeddedCSS,
+                EndDate = settings.EndDate,
+                TargetAmount = settings.TargetAmount,
+                CustomCSSLink = settings.CustomCSSLink,
+                NotificationUrl = settings.NotificationUrl,
+                Tagline = settings.Tagline,
+                PerksTemplate = settings.PerksTemplate,
+                DisqusEnabled = settings.DisqusEnabled,
+                SoundsEnabled = settings.SoundsEnabled,
+                DisqusShortname = settings.DisqusShortname,
+                AnimationsEnabled = settings.AnimationsEnabled,
+                ResetEveryAmount = settings.ResetEveryAmount,
+                ResetEvery = Enum.GetName(typeof(CrowdfundResetEvery), settings.ResetEvery),
+                UseAllStoreInvoices = app.TagAllInvoices,
+                AppId = appId,
+                SearchTerm = app.TagAllInvoices ? $"storeid:{app.StoreDataId}" : $"orderid:{AppService.GetCrowdfundOrderId(appId)}",
+                DisplayPerksRanking = settings.DisplayPerksRanking,
+                SortPerksByPopularity = settings.SortPerksByPopularity,
+                Sounds                = string.Join(Environment.NewLine, settings.Sounds),
+                AnimationColors                = string.Join(Environment.NewLine, settings.AnimationColors)
+            };
+            return View(vm);
+        }
+        [HttpPost]
+        [Route("{appId}/settings/crowdfund")]
+        public async Task<IActionResult> UpdateCrowdfund(string appId, UpdateCrowdfundViewModel vm)
+        {
+            if (!string.IsNullOrEmpty( vm.TargetCurrency) && _currencies.GetCurrencyData(vm.TargetCurrency, false) == null)
+                ModelState.AddModelError(nameof(vm.TargetCurrency), "Invalid currency");
+          
+            try
+            {
+                _AppService.Parse(vm.PerksTemplate, vm.TargetCurrency).ToString();
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(vm.PerksTemplate), "Invalid template");
+            }
+
+            if (Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery) != CrowdfundResetEvery.Never && !vm.StartDate.HasValue)
+            {
+                ModelState.AddModelError(nameof(vm.StartDate), "A start date is needed when the goal resets every X amount of time.");
+            }
+
+            if (Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery) != CrowdfundResetEvery.Never && vm.ResetEveryAmount <= 0)
+            {
+                ModelState.AddModelError(nameof(vm.ResetEveryAmount), "You must reset the goal at a minimum of 1 ");
+            }
+
+            if (vm.DisplayPerksRanking && !vm.SortPerksByPopularity)
+            {
+                ModelState.AddModelError(nameof(vm.DisplayPerksRanking), "You must sort by popularity in order to display ranking.");
+            }
+
+            var parsedSounds = vm.Sounds.Split(
+                new[] {"\r\n", "\r", "\n"},
+                StringSplitOptions.None
+            ).Select(s => s.Trim()).ToArray();
+            if (vm.SoundsEnabled && !parsedSounds.Any())
+            {
+                ModelState.AddModelError(nameof(vm.Sounds), "You must have at least one sound if you enable sounds");
+            }
+            
+            var parsedAnimationColors = vm.AnimationColors.Split(
+                new[] { "\r\n", "\r", "\n" },
+                StringSplitOptions.None
+            ).Select(s => s.Trim()).ToArray();
+            if (vm.AnimationsEnabled && !parsedAnimationColors.Any())
+            {
+                ModelState.AddModelError(nameof(vm.AnimationColors), "You must have at least one animation color if you enable animations");
+            }
+            
+            if (!ModelState.IsValid)
+            {
+                return View(vm);
+            }
+            
+            
+            var app = await GetOwnedApp(appId, AppType.Crowdfund);
+            if (app == null)
+                return NotFound();
+
+            var newSettings = new CrowdfundSettings()
+            {
+                Title = vm.Title,
+                Enabled = vm.Enabled,
+                EnforceTargetAmount = vm.EnforceTargetAmount,
+                StartDate = vm.StartDate,
+                TargetCurrency = vm.TargetCurrency,
+                Description = _htmlSanitizer.Sanitize( vm.Description),
+                EndDate = vm.EndDate,
+                TargetAmount = vm.TargetAmount,
+                CustomCSSLink = vm.CustomCSSLink,
+                MainImageUrl = vm.MainImageUrl,
+                EmbeddedCSS = vm.EmbeddedCSS,
+                NotificationUrl = vm.NotificationUrl,
+                NotificationEmail = vm.NotificationEmail,
+                Tagline = vm.Tagline,
+                PerksTemplate = vm.PerksTemplate,
+                DisqusEnabled = vm.DisqusEnabled,
+                SoundsEnabled = vm.SoundsEnabled,
+                DisqusShortname = vm.DisqusShortname,
+                AnimationsEnabled = vm.AnimationsEnabled,
+                ResetEveryAmount = vm.ResetEveryAmount,
+                ResetEvery = Enum.Parse<CrowdfundResetEvery>(vm.ResetEvery),
+                DisplayPerksRanking = vm.DisplayPerksRanking,
+                SortPerksByPopularity = vm.SortPerksByPopularity,
+                Sounds = parsedSounds,
+                AnimationColors = parsedAnimationColors
+            };
+
+            app.TagAllInvoices = vm.UseAllStoreInvoices;
+            app.SetSettings(newSettings);
+            await UpdateAppSettings(app);
+
+            _EventAggregator.Publish(new AppUpdated()
+            {
+                AppId = appId,
+                StoreId = app.StoreDataId,
+                Settings = newSettings
+            });
+            StatusMessage = "App updated";
+            return RedirectToAction(nameof(UpdateCrowdfund), new {appId});
+        }
+    }
+}

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -0,0 +1,225 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Mails;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class AppsController
+    {
+        public class PointOfSaleSettings
+        {
+            public PointOfSaleSettings()
+            {
+                Title = "Tea shop";
+                Currency = "USD";
+                Template =
+                    "green tea:\n" +
+                    "  price: 1\n" +
+                    "  title: Green Tea\n" +
+                    "  description:  Lovely, fresh and tender, Meng Ding Gan Lu ('sweet dew') is grown in the lush Meng Ding Mountains of the southwestern province of Sichuan where it has been cultivated for over a thousand years.\n" +
+                    "  image: https://cdn.pixabay.com/photo/2015/03/26/11/03/green-tea-692339__480.jpg\n\n" +
+                    "black tea:\n" +
+                    "  price: 1\n" +
+                    "  title: Black Tea\n" +
+                    "  description: Tian Jian Tian Jian means 'heavenly tippy tea' in Chinese, and it describes the finest grade of dark tea. Our Tian Jian dark tea is from Hunan province which is famous for making some of the best dark teas available.\n" +
+                    "  image: https://cdn.pixabay.com/photo/2016/11/29/13/04/beverage-1869716__480.jpg\n\n" +
+                    "rooibos:\n" +
+                    "  price: 1.2\n" +
+                    "  title: Rooibos\n" +
+                    "  description: Rooibos is a dramatic red tea made from a South African herb that contains polyphenols and flavonoids. Often called 'African redbush tea', Rooibos herbal tea delights the senses and delivers potential health benefits with each caffeine-free sip.\n" +
+                    "  image: https://cdn.pixabay.com/photo/2017/01/08/08/14/water-1962388__480.jpg\n\n" +
+                    "pu erh:\n" +
+                    "  price: 2\n" +
+                    "  title: Pu Erh\n" +
+                    "  description: This loose pur-erh tea is produced in Yunnan Province, China. The process in a relatively high humidity environment has mellowed the elemental character of the tea when compared to young Pu-erh.\n" +
+                    "  image: https://cdn.pixabay.com/photo/2018/07/21/16/56/tea-cup-3552917__480.jpg\n\n" +
+                    "herbal tea:\n" +
+                    "  price: 1.8\n" +
+                    "  title: Herbal Tea\n" +
+                    "  description: Chamomile tea is made from the flower heads of the chamomile plant. The medicinal use of chamomile dates back to the ancient Egyptians, Romans and Greeks. Pay us what you want!\n" +
+                    "  image: https://cdn.pixabay.com/photo/2015/07/02/20/57/chamomile-829538__480.jpg\n" +
+                    "  custom: true\n\n" +
+                    "fruit tea:\n" +
+                    "  price: 1.5\n" +
+                    "  title: Fruit Tea\n" +
+                    "  description: The Tibetan Himalayas, the land is majestic and beautiful—a spiritual place where, despite the perilous environment, many journey seeking enlightenment. Pay us what you want!\n" +
+                    "  image: https://cdn.pixabay.com/photo/2016/09/16/11/24/darts-1673812__480.jpg\n" +
+                    "  custom: true";
+                EnableShoppingCart = false;
+                ShowCustomAmount = true;
+                ShowDiscount = true;
+                EnableTips = true;
+            }
+            public string Title { get; set; }
+            public string Currency { get; set; }
+            public string Template { get; set; }
+            public bool EnableShoppingCart { get; set; }
+            public bool ShowCustomAmount { get; set; }
+            public bool ShowDiscount { get; set; }
+            public bool EnableTips { get; set; }
+
+            public const string BUTTON_TEXT_DEF = "Buy for {0}";
+            public string ButtonText { get; set; } = BUTTON_TEXT_DEF;
+            public const string CUSTOM_BUTTON_TEXT_DEF = "Pay";
+            public string CustomButtonText { get; set; } = CUSTOM_BUTTON_TEXT_DEF;
+            public const string CUSTOM_TIP_TEXT_DEF = "Do you want to leave a tip?";
+            public string CustomTipText { get; set; } = CUSTOM_TIP_TEXT_DEF;
+            public static readonly int[] CUSTOM_TIP_PERCENTAGES_DEF = new int[] { 15, 18, 20 };
+            public int[] CustomTipPercentages { get; set; } = CUSTOM_TIP_PERCENTAGES_DEF;
+
+
+            public string CustomCSSLink { get; set; }
+            public string NotificationEmail { get; set; }
+            public string NotificationUrl { get; set; }
+            public bool? RedirectAutomatically { get; set; }
+        }
+
+        [HttpGet]
+        [Route("{appId}/settings/pos")]
+        public async Task<IActionResult> UpdatePointOfSale(string appId)
+        {
+            var app = await GetOwnedApp(appId, AppType.PointOfSale);
+            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,
+                ShowCustomAmount = settings.ShowCustomAmount,
+                ShowDiscount = settings.ShowDiscount,
+                EnableTips = settings.EnableTips,
+                Currency = settings.Currency,
+                Template = settings.Template,
+                ButtonText = settings.ButtonText ?? PointOfSaleSettings.BUTTON_TEXT_DEF,
+                CustomButtonText = settings.CustomButtonText ?? PointOfSaleSettings.CUSTOM_BUTTON_TEXT_DEF,
+                CustomTipText = settings.CustomTipText ?? PointOfSaleSettings.CUSTOM_TIP_TEXT_DEF,
+                CustomTipPercentages = settings.CustomTipPercentages != null ? string.Join(",", settings.CustomTipPercentages) : string.Join(",", PointOfSaleSettings.CUSTOM_TIP_PERCENTAGES_DEF),
+                CustomCSSLink = settings.CustomCSSLink,
+                NotificationEmail = settings.NotificationEmail,
+                NotificationUrl = settings.NotificationUrl,
+                RedirectAutomatically = settings.RedirectAutomatically.HasValue? settings.RedirectAutomatically.Value? "true": "false" : "" 
+            };
+            if (HttpContext?.Request != null)
+            {
+                var appUrl = HttpContext.Request.GetAbsoluteRoot().WithTrailingSlash() + $"apps/{appId}/pos";
+                var encoder = HtmlEncoder.Default;
+                if (settings.ShowCustomAmount)
+                {
+                    StringBuilder builder = new StringBuilder();
+                    builder.AppendLine($"<form method=\"POST\" action=\"{encoder.Encode(appUrl)}\">");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"amount\" value=\"100\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"email\" value=\"customer@example.com\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"orderId\" value=\"CustomOrderId\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"notificationUrl\" value=\"https://example.com/callbacks\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"redirectUrl\" value=\"https://example.com/thanksyou\" />");
+                    builder.AppendLine($"  <button type=\"submit\">Buy now</button>");
+                    builder.AppendLine($"</form>");
+                    vm.Example1 = builder.ToString();
+                }
+                try
+                {
+                    var items = _AppService.Parse(settings.Template, settings.Currency);
+                    var builder = new StringBuilder();
+                    builder.AppendLine($"<form method=\"POST\" action=\"{encoder.Encode(appUrl)}\">");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"email\" value=\"customer@example.com\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"orderId\" value=\"CustomOrderId\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"notificationUrl\" value=\"https://example.com/callbacks\" />");
+                    builder.AppendLine($"  <input type=\"hidden\" name=\"redirectUrl\" value=\"https://example.com/thanksyou\" />");
+                    builder.AppendLine($"  <button type=\"submit\" name=\"choiceKey\" value=\"{items[0].Id}\">Buy now</button>");
+                    builder.AppendLine($"</form>");
+                    vm.Example2 = builder.ToString();
+                }
+                catch { }
+                vm.InvoiceUrl = appUrl + "invoices/SkdsDghkdP3D3qkj7bLq3";
+            }
+
+            vm.ExampleCallback = "{\n  \"id\":\"SkdsDghkdP3D3qkj7bLq3\",\n  \"url\":\"https://btcpay.example.com/invoice?id=SkdsDghkdP3D3qkj7bLq3\",\n  \"status\":\"paid\",\n  \"price\":10,\n  \"currency\":\"EUR\",\n  \"invoiceTime\":1520373130312,\n  \"expirationTime\":1520374030312,\n  \"currentTime\":1520373179327,\n  \"exceptionStatus\":false,\n  \"buyerFields\":{\n    \"buyerEmail\":\"customer@example.com\",\n    \"buyerNotify\":false\n  },\n  \"paymentSubtotals\": {\n    \"BTC\":114700\n  },\n  \"paymentTotals\": {\n    \"BTC\":118400\n  },\n  \"transactionCurrency\": \"BTC\",\n  \"amountPaid\": \"1025900\",\n  \"exchangeRates\": {\n    \"BTC\": {\n      \"EUR\": 8721.690715789999,\n      \"USD\": 10817.99\n    }\n  }\n}";
+            return View(vm);
+        }
+        [HttpPost]
+        [Route("{appId}/settings/pos")]
+        public async Task<IActionResult> UpdatePointOfSale(string appId, UpdatePointOfSaleViewModel vm)
+        {
+            if (_currencies.GetCurrencyData(vm.Currency, false) == null)
+                ModelState.AddModelError(nameof(vm.Currency), "Invalid currency");
+            try
+            {
+                _AppService.Parse(vm.Template, vm.Currency);
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(vm.Template), "Invalid template");
+            }
+            if (!ModelState.IsValid)
+            {
+                return View(vm);
+            }
+            var app = await GetOwnedApp(appId, AppType.PointOfSale);
+            if (app == null)
+                return NotFound();
+            app.SetSettings(new PointOfSaleSettings()
+            {
+                Title = vm.Title,
+                EnableShoppingCart = vm.EnableShoppingCart,
+                ShowCustomAmount = vm.ShowCustomAmount,
+                ShowDiscount = vm.ShowDiscount,
+                EnableTips = vm.EnableTips,
+                Currency = vm.Currency.ToUpperInvariant(),
+                Template = vm.Template,
+                ButtonText = vm.ButtonText,
+                CustomButtonText = vm.CustomButtonText,
+                CustomTipText = vm.CustomTipText,
+                CustomTipPercentages = ListSplit(vm.CustomTipPercentages),
+                CustomCSSLink = vm.CustomCSSLink,
+                NotificationUrl = vm.NotificationUrl,
+                NotificationEmail = vm.NotificationEmail,
+                RedirectAutomatically = string.IsNullOrEmpty(vm.RedirectAutomatically)? (bool?) null: bool.Parse(vm.RedirectAutomatically)
+                
+            });
+            await UpdateAppSettings(app);
+            StatusMessage = "App updated";
+            return RedirectToAction(nameof(ListApps));
+        }
+
+        private async Task UpdateAppSettings(AppData app)
+        {
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                ctx.Apps.Add(app);
+                ctx.Entry<AppData>(app).State = EntityState.Modified;
+                ctx.Entry<AppData>(app).Property(a => a.Settings).IsModified = true;
+                ctx.Entry<AppData>(app).Property(a => a.TagAllInvoices).IsModified = true;
+                await ctx.SaveChangesAsync();
+            }
+        }
+
+        private int[] ListSplit(string list, string separator = ",")
+        {
+            if (string.IsNullOrEmpty(list))
+            {
+                return Array.Empty<int>();
+            } 
+            else 
+            {
+                // Remove all characters except numeric and comma
+                Regex charsToDestroy = new Regex(@"[^\d|\" + separator + "]");
+                list = charsToDestroy.Replace(list, "");
+
+                return list.Split(separator, System.StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();
+            }
+        }
+    }
+}

BTCPayServer/Controllers/AppsController.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+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;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using NBitcoin;
+using NBitcoin.DataEncoders;
+
+namespace BTCPayServer.Controllers
+{
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [AutoValidateAntiforgeryToken]
+    [Route("apps")]
+    public partial class AppsController : Controller
+    {
+        public AppsController(
+            UserManager<ApplicationUser> userManager,
+            ApplicationDbContextFactory contextFactory,
+            EventAggregator eventAggregator,
+            BTCPayNetworkProvider networkProvider,
+            CurrencyNameTable currencies,
+            HtmlSanitizer htmlSanitizer,
+            EmailSenderFactory emailSenderFactory,
+            AppService AppService)
+        {
+            _UserManager = userManager;
+            _ContextFactory = contextFactory;
+            _EventAggregator = eventAggregator;
+            _NetworkProvider = networkProvider;
+            _currencies = currencies;
+            _htmlSanitizer = htmlSanitizer;
+            _emailSenderFactory = emailSenderFactory;
+            _AppService = AppService;
+        }
+
+        private UserManager<ApplicationUser> _UserManager;
+        private ApplicationDbContextFactory _ContextFactory;
+        private readonly EventAggregator _EventAggregator;
+        private BTCPayNetworkProvider _NetworkProvider;
+        private readonly CurrencyNameTable _currencies;
+        private readonly HtmlSanitizer _htmlSanitizer;
+        private readonly EmailSenderFactory _emailSenderFactory;
+        private AppService _AppService;
+
+        [TempData]
+        public string StatusMessage { get; set; }
+        public string CreatedAppId { get; set; }
+
+        public async Task<IActionResult> ListApps()
+        {
+            var apps = await _AppService.GetAllApps(GetUserId());
+            return View(new ListAppsViewModel()
+            {
+                Apps = apps
+            });
+        }
+
+        [HttpPost]
+        [Route("{appId}/delete")]
+        public async Task<IActionResult> DeleteAppPost(string appId)
+        {
+            var appData = await GetOwnedApp(appId);
+            if (appData == null)
+                return NotFound();
+            if (await _AppService.DeleteApp(appData))
+                StatusMessage = "App removed successfully";
+            return RedirectToAction(nameof(ListApps));
+        }
+
+        [HttpGet]
+        [Route("create")]
+        public async Task<IActionResult> CreateApp()
+        {
+            var stores = await _AppService.GetOwnedStores(GetUserId());
+            if (stores.Length == 0)
+            {
+                StatusMessage = new StatusMessageModel()
+                {
+                    Html =
+                        $"Error: You need to create at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
+                    Severity = StatusMessageModel.StatusSeverity.Error
+                }.ToString();
+                return RedirectToAction(nameof(ListApps));
+            }
+            var vm = new CreateAppViewModel();
+            vm.SetStores(stores);
+            return View(vm);
+        }
+
+        [HttpPost]
+        [Route("create")]
+        public async Task<IActionResult> CreateApp(CreateAppViewModel vm)
+        {
+            var stores = await _AppService.GetOwnedStores(GetUserId());
+            if (stores.Length == 0)
+            {
+                StatusMessage = new StatusMessageModel()
+                {
+                    Html =
+                        $"Error: You need to create at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
+                    Severity = StatusMessageModel.StatusSeverity.Error
+                }.ToString();
+                return RedirectToAction(nameof(ListApps));
+            }
+            var selectedStore = vm.SelectedStore;
+            vm.SetStores(stores);
+            vm.SelectedStore = selectedStore;
+
+            if (!Enum.TryParse<AppType>(vm.SelectedAppType, out AppType appType))
+                ModelState.AddModelError(nameof(vm.SelectedAppType), "Invalid App Type");
+
+            if (!ModelState.IsValid)
+            {
+                return View(vm);
+            }
+
+            if (!stores.Any(s => s.Id == selectedStore))
+            {
+                StatusMessage = "Error: You are not owner of this store";
+                return RedirectToAction(nameof(ListApps));
+            }
+            var id = Encoders.Base58.EncodeData(RandomUtils.GetBytes(20));
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                var appData = new AppData() { Id = id };
+                appData.StoreDataId = selectedStore;
+                appData.Name = vm.Name;
+                appData.AppType = appType.ToString();
+                ctx.Apps.Add(appData);
+                await ctx.SaveChangesAsync();
+            }
+            StatusMessage = "App successfully created";
+            CreatedAppId = id;
+
+            switch (appType)
+            {
+                case AppType.PointOfSale:
+                    return RedirectToAction(nameof(UpdatePointOfSale), new { appId = id });
+                case AppType.Crowdfund:
+                    return RedirectToAction(nameof(UpdateCrowdfund), new { appId = id });
+                default:
+                    return RedirectToAction(nameof(ListApps));
+            }
+                
+        }
+
+        [HttpGet]
+        [Route("{appId}/delete")]
+        public async Task<IActionResult> DeleteApp(string appId)
+        {
+            var appData = await GetOwnedApp(appId);
+            if (appData == null)
+                return NotFound();
+            return View("Confirm", new ConfirmModel()
+            {
+                Title = $"Delete app {appData.Name} ({appData.AppType})",
+                Description = "This app will be removed from this store",
+                Action = "Delete"
+            });
+        }
+
+        private Task<AppData> GetOwnedApp(string appId, AppType? type = null)
+        {
+            return _AppService.GetAppDataIfOwner(GetUserId(), appId, type);
+        }
+
+        
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+
+        private async Task<bool> IsEmailConfigured(string storeId)
+        {
+            return (await (_emailSenderFactory.GetEmailSender(storeId) as EmailSender)?.GetEmailSettings())?.IsComplete() is true;
+        }
+    }
+}

BTCPayServer/Controllers/AppsPublicController.cs

@@ -0,0 +1,295 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Configuration;
+using BTCPayServer.Data;
+using BTCPayServer.Filters;
+using BTCPayServer.ModelBinders;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Payments;
+using BTCPayServer.Rating;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using Ganss.XSS;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using NBitpayClient;
+using YamlDotNet.RepresentationModel;
+using static BTCPayServer.Controllers.AppsController;
+
+namespace BTCPayServer.Controllers
+{
+    public class AppsPublicController : Controller
+    {
+        public AppsPublicController(AppService AppService,
+            BTCPayServerOptions btcPayServerOptions,
+            InvoiceController invoiceController,
+            UserManager<ApplicationUser> userManager)
+        {
+            _AppService = AppService;
+            _BtcPayServerOptions = btcPayServerOptions;
+            _InvoiceController = invoiceController;
+            _UserManager = userManager;
+        }
+
+        private AppService _AppService;
+        private readonly BTCPayServerOptions _BtcPayServerOptions;
+        private InvoiceController _InvoiceController;
+        private readonly UserManager<ApplicationUser> _UserManager;
+
+        [HttpGet]
+        [Route("/apps/{appId}/pos")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        public async Task<IActionResult> ViewPointOfSale(string appId)
+        {
+            var app = await _AppService.GetApp(appId, AppType.PointOfSale);
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<PointOfSaleSettings>();
+
+            var numberFormatInfo = _AppService.Currencies.GetNumberFormatInfo(settings.Currency) ?? _AppService.Currencies.GetNumberFormatInfo("USD");
+            double step = Math.Pow(10, -(numberFormatInfo.CurrencyDecimalDigits));
+
+            return View(new ViewPointOfSaleViewModel()
+            {
+                Title = settings.Title,
+                Step = step.ToString(CultureInfo.InvariantCulture),
+                EnableShoppingCart = settings.EnableShoppingCart,
+                ShowCustomAmount = settings.ShowCustomAmount,
+                ShowDiscount = settings.ShowDiscount,
+                EnableTips = settings.EnableTips,
+                CurrencyCode = settings.Currency,
+                CurrencySymbol = numberFormatInfo.CurrencySymbol,
+                CurrencyInfo = new ViewPointOfSaleViewModel.CurrencyInfoData()
+                {
+                    CurrencySymbol = string.IsNullOrEmpty(numberFormatInfo.CurrencySymbol) ? settings.Currency : numberFormatInfo.CurrencySymbol,
+                    Divisibility = numberFormatInfo.CurrencyDecimalDigits,
+                    DecimalSeparator = numberFormatInfo.CurrencyDecimalSeparator,
+                    ThousandSeparator = numberFormatInfo.NumberGroupSeparator,
+                    Prefixed = new[] { 0, 2 }.Contains(numberFormatInfo.CurrencyPositivePattern),
+                    SymbolSpace = new[] { 2, 3 }.Contains(numberFormatInfo.CurrencyPositivePattern)
+                },
+                Items = _AppService.Parse(settings.Template, settings.Currency),
+                ButtonText = settings.ButtonText,
+                CustomButtonText = settings.CustomButtonText,
+                CustomTipText = settings.CustomTipText,
+                CustomTipPercentages = settings.CustomTipPercentages,
+                CustomCSSLink = settings.CustomCSSLink,
+                AppId = appId
+            });
+        }
+
+
+        [HttpGet]
+        [Route("/apps/{appId}/crowdfund")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        public async Task<IActionResult> ViewCrowdfund(string appId, string statusMessage)
+        {
+            var app = await _AppService.GetApp(appId, AppType.Crowdfund, true);
+
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<CrowdfundSettings>();
+
+            var isAdmin = await _AppService.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
+
+            var hasEnoughSettingsToLoad = !string.IsNullOrEmpty(settings.TargetCurrency);
+            if (!hasEnoughSettingsToLoad)
+            {
+                if (!isAdmin)
+                    return NotFound();
+
+                return NotFound("A Target Currency must be set for this app in order to be loadable.");
+            }
+            var appInfo = (ViewCrowdfundViewModel)(await _AppService.GetAppInfo(appId));
+            appInfo.HubPath = AppHub.GetHubPath(this.Request);
+            if (settings.Enabled)
+                return View(appInfo);
+            if (!isAdmin)
+                return NotFound();
+
+            return View(appInfo);
+        }
+
+        [HttpPost]
+        [Route("/apps/{appId}/crowdfund")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        [IgnoreAntiforgeryToken]
+        [EnableCors(CorsPolicies.All)]
+        public async Task<IActionResult> ContributeToCrowdfund(string appId, ContributeToCrowdfund request, CancellationToken cancellationToken)
+        {
+            var app = await _AppService.GetApp(appId, AppType.Crowdfund, true);
+
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<CrowdfundSettings>();
+
+
+            var isAdmin = await _AppService.GetAppDataIfOwner(GetUserId(), appId, AppType.Crowdfund) != null;
+
+            if (!settings.Enabled && !isAdmin)
+            {
+                return NotFound("Crowdfund is not currently active");
+            }
+
+            var info = (ViewCrowdfundViewModel)await _AppService.GetAppInfo(appId);
+            info.HubPath = AppHub.GetHubPath(this.Request);
+            if (!isAdmin &&
+                ((settings.StartDate.HasValue && DateTime.Now < settings.StartDate) ||
+                 (settings.EndDate.HasValue && DateTime.Now > settings.EndDate) ||
+                 (settings.EnforceTargetAmount &&
+                  (info.Info.PendingProgressPercentage.GetValueOrDefault(0) +
+                   info.Info.ProgressPercentage.GetValueOrDefault(0)) >= 100)))
+            {
+                return NotFound("Crowdfund is not currently active");
+            }
+
+            var store = await _AppService.GetStore(app);
+            var title = settings.Title;
+            var price = request.Amount;
+            ViewPointOfSaleViewModel.Item choice = null;
+            if (!string.IsNullOrEmpty(request.ChoiceKey))
+            {
+                var choices = _AppService.Parse(settings.PerksTemplate, settings.TargetCurrency);
+                choice = choices.FirstOrDefault(c => c.Id == request.ChoiceKey);
+                if (choice == null)
+                    return NotFound("Incorrect option provided");
+                title = choice.Title;
+                price = choice.Price.Value;
+                if (request.Amount > price)
+                    price = request.Amount;
+            }
+
+            if (!isAdmin && (settings.EnforceTargetAmount && info.TargetAmount.HasValue && price >
+                             (info.TargetAmount - (info.Info.CurrentAmount + info.Info.CurrentPendingAmount))))
+            {
+                return NotFound("Contribution Amount is more than is currently allowed.");
+            }
+
+            store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
+            try
+            {
+                var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
+                    {
+                        OrderId = AppService.GetCrowdfundOrderId(appId),
+                        Currency = settings.TargetCurrency,
+                        ItemCode = request.ChoiceKey ?? string.Empty,
+                        ItemDesc = title,
+                        BuyerEmail = request.Email,
+                        Price = price,
+                        NotificationURL = settings.NotificationUrl,
+                        NotificationEmail = settings.NotificationEmail,
+                        FullNotifications = true,
+                        ExtendedNotifications = true,
+                        RedirectURL = request.RedirectUrl ?? 
+                                     new Uri(new Uri( new Uri(HttpContext.Request.GetAbsoluteRoot()),  _BtcPayServerOptions.RootPath), $"apps/{appId}/crowdfund").ToString()
+                    }, store, HttpContext.Request.GetAbsoluteRoot(),
+                    new List<string> {AppService.GetAppInternalTag(appId)},
+                    cancellationToken: cancellationToken);
+                if (request.RedirectToCheckout)
+                {
+                    return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice",
+                        new { invoiceId = invoice.Data.Id });
+                }
+                else
+                {
+                    return Ok(invoice.Data.Id);
+                }
+            }
+            catch (BitpayHttpException e)
+            {
+                return BadRequest(e.Message);
+            }
+
+        }
+
+        [HttpPost]
+        [Route("/apps/{appId}/pos")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        [IgnoreAntiforgeryToken]
+        [EnableCors(CorsPolicies.All)]
+        public async Task<IActionResult> ViewPointOfSale(string appId,
+                                                        [ModelBinder(typeof(InvariantDecimalModelBinder))] decimal amount,
+                                                        string email,
+                                                        string orderId,
+                                                        string notificationUrl,
+                                                        string redirectUrl,
+                                                        string choiceKey,
+                                                        string posData = null, CancellationToken cancellationToken = default)
+        {
+            var app = await _AppService.GetApp(appId, AppType.PointOfSale);
+            if (string.IsNullOrEmpty(choiceKey) && amount <= 0)
+            {
+                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
+            }
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<PointOfSaleSettings>();
+            if (string.IsNullOrEmpty(choiceKey) && !settings.ShowCustomAmount && !settings.EnableShoppingCart)
+            {
+                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
+            }
+            string title = null;
+            var price = 0.0m;
+            ViewPointOfSaleViewModel.Item choice = null;
+            if (!string.IsNullOrEmpty(choiceKey))
+            {
+                var choices = _AppService.Parse(settings.Template, settings.Currency);
+                choice = choices.FirstOrDefault(c => c.Id == choiceKey);
+                if (choice == null)
+                    return NotFound();
+                title = choice.Title;
+                price = choice.Price.Value;
+                if (amount > price)
+                    price = amount;
+            }
+            else
+            {
+                if (!settings.ShowCustomAmount && !settings.EnableShoppingCart)
+                    return NotFound();
+                price = amount;
+                title = settings.Title;
+            }
+            var store = await _AppService.GetStore(app);
+            store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
+            var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
+            {
+                ItemCode = choice?.Id,
+                ItemDesc = title,
+                Currency = settings.Currency,
+                Price = price,
+                BuyerEmail = email,
+                OrderId = orderId,
+                NotificationURL =
+                        string.IsNullOrEmpty(notificationUrl) ? settings.NotificationUrl : notificationUrl,
+                NotificationEmail = settings.NotificationEmail,
+                RedirectURL = redirectUrl ?? Request.GetDisplayUrl(),
+                FullNotifications = true,
+                ExtendedNotifications = true,
+                PosData = string.IsNullOrEmpty(posData) ? null : posData,
+                RedirectAutomatically = settings.RedirectAutomatically,
+            }, store, HttpContext.Request.GetAbsoluteRoot(),
+                new List<string>() { AppService.GetAppInternalTag(appId) },
+                cancellationToken);
+            return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice", new { invoiceId = invoice.Data.Id });
+        }
+
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+    }
+}

BTCPayServer/Controllers/ChangellyController.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Models;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Rating;
+using BTCPayServer.Services.Rates;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Controllers
+{
+    [Route("[controller]/{storeId}")]
+    public class ChangellyController : Controller
+    {
+        private readonly ChangellyClientProvider _changellyClientProvider;
+        private readonly BTCPayNetworkProvider _btcPayNetworkProvider;
+        private readonly RateFetcher _RateProviderFactory;
+
+        public ChangellyController(ChangellyClientProvider changellyClientProvider,
+            BTCPayNetworkProvider btcPayNetworkProvider,
+            RateFetcher rateProviderFactory)
+        {
+            _RateProviderFactory = rateProviderFactory ?? throw new ArgumentNullException(nameof(rateProviderFactory));
+
+            _changellyClientProvider = changellyClientProvider;
+            _btcPayNetworkProvider = btcPayNetworkProvider;
+        }
+
+        [HttpGet]
+        [Route("currencies")]
+        public async Task<IActionResult> GetCurrencyList(string storeId)
+        {
+            try
+            {
+                
+                var client = await TryGetChangellyClient(storeId);
+                
+                return Ok(await client.GetCurrenciesFull());
+            }
+            catch (Exception e)
+            {
+                return BadRequest(new BitpayErrorModel()
+                {
+                    Error = e.Message
+                });
+            }
+        }
+
+        [HttpGet]
+        [Route("calculate")]
+        public async Task<IActionResult> CalculateAmount(string storeId, string fromCurrency, string toCurrency,
+            decimal toCurrencyAmount, CancellationToken cancellationToken)
+        {
+            try
+            {
+                var client = await TryGetChangellyClient(storeId);
+
+                if (fromCurrency.Equals("usd", StringComparison.InvariantCultureIgnoreCase)
+                    || fromCurrency.Equals("eur", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return await HandleCalculateFiatAmount(fromCurrency, toCurrency, toCurrencyAmount, cancellationToken);
+                }
+                
+                var callCounter = 0;
+                var baseRate = await client.GetExchangeAmount(fromCurrency, toCurrency, 1);
+                var currentAmount = ChangellyCalculationHelper.ComputeBaseAmount(baseRate, toCurrencyAmount);
+                while (true)
+                {
+                    if (callCounter > 10)
+                    {
+                        BadRequest();
+                    }
+
+                    var computedAmount = await client.GetExchangeAmount(fromCurrency, toCurrency, currentAmount);
+                    callCounter++;
+                    if (computedAmount < toCurrencyAmount)
+                    {
+                        currentAmount =
+                            ChangellyCalculationHelper.ComputeCorrectAmount(currentAmount, computedAmount,
+                                toCurrencyAmount);
+                    }
+                    else
+                    {
+                        return Ok(currentAmount);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                return BadRequest(new BitpayErrorModel()
+                {
+                    Error = e.Message
+                });
+            }
+        }
+
+        private async Task<Changelly> TryGetChangellyClient(string storeId)
+        {
+            var store = IsTest? null: HttpContext.GetStoreData();
+            storeId = storeId ?? store?.Id;
+
+            return await _changellyClientProvider.TryGetChangellyClient(storeId, store);
+        }
+
+        private async Task<IActionResult> HandleCalculateFiatAmount(string fromCurrency, string toCurrency,
+            decimal toCurrencyAmount, CancellationToken cancellationToken)
+        {
+            var store = HttpContext.GetStoreData();
+            var rules = store.GetStoreBlob().GetRateRules(_btcPayNetworkProvider);
+            var rate = await _RateProviderFactory.FetchRate(new CurrencyPair(toCurrency, fromCurrency), rules, cancellationToken);
+            if (rate.BidAsk == null) return BadRequest();
+            var flatRate = rate.BidAsk.Center;
+            return Ok(flatRate * toCurrencyAmount);
+        }
+
+        public bool IsTest { get; set; } = false;
+    }
+    
+    
+}

BTCPayServer/Controllers/HomeController.cs

@@ -1,20 +1,107 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using BTCPayServer.Models;
+using NBitcoin.Payment;
+using System.Net.Http;
+using Newtonsoft.Json.Linq;
+using NBitcoin;
+using Newtonsoft.Json;
+using BTCPayServer.Services;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer.Controllers
 {
     public class HomeController : Controller
     {
-        public IActionResult Index()
+        private readonly CssThemeManager _cachedServerSettings;
+
+        public IHttpClientFactory HttpClientFactory { get; }
+
+        public HomeController(IHttpClientFactory httpClientFactory, CssThemeManager cachedServerSettings)
         {
+            HttpClientFactory = httpClientFactory;
+            _cachedServerSettings = cachedServerSettings;
+        }
+        
+        public async Task<IActionResult> Index()
+        {
+            if (_cachedServerSettings.RootAppType is Services.Apps.AppType.Crowdfund)
+            {
+                var serviceProvider = HttpContext.RequestServices;
+                var controller = (AppsPublicController)serviceProvider.GetService(typeof(AppsPublicController));
+                controller.Url = Url;
+                controller.ControllerContext = ControllerContext;
+                var res = await controller.ViewCrowdfund(_cachedServerSettings.RootAppId, null) as ViewResult;
+                if (res != null)
+                {
+                    res.ViewName = "/Views/AppsPublic/ViewCrowdfund.cshtml";
+                    return res; // return 
+                }
+            }
+
             return View("Home");
         }
 
+        [Route("translate")]
+        public IActionResult BitpayTranslator()
+        {
+            return View(new BitpayTranslatorViewModel());
+        }
+
+        [HttpPost]
+        [Route("translate")]
+        public async Task<IActionResult> BitpayTranslator(BitpayTranslatorViewModel vm)
+        {
+            if (!ModelState.IsValid)
+                return View(vm);
+            vm.BitpayLink = vm.BitpayLink ?? string.Empty;
+            vm.BitpayLink = vm.BitpayLink.Trim();
+            if (!vm.BitpayLink.StartsWith("bitcoin:", StringComparison.OrdinalIgnoreCase))
+            {
+                var invoiceId = vm.BitpayLink.Substring(vm.BitpayLink.LastIndexOf("=", StringComparison.OrdinalIgnoreCase) + 1);
+                vm.BitpayLink = $"bitcoin:?r=https://bitpay.com/i/{invoiceId}";
+            }
+
+            try
+            {
+                BitcoinUrlBuilder urlBuilder = new BitcoinUrlBuilder(vm.BitpayLink);
+#pragma warning disable CS0618 // Type or member is obsolete
+                if (!urlBuilder.PaymentRequestUrl.DnsSafeHost.EndsWith("bitpay.com", StringComparison.OrdinalIgnoreCase))
+                {
+                    throw new Exception("This tool only work with bitpay");
+                }
+
+                var client = HttpClientFactory.CreateClient();
+                HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, urlBuilder.PaymentRequestUrl);
+#pragma warning restore CS0618 // Type or member is obsolete
+                request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/payment-request"));
+                var result = await client.SendAsync(request);
+                // {"network":"main","currency":"BTC","requiredFeeRate":29.834,"outputs":[{"amount":255900,"address":"1PgPo5d4swD6pKfCgoXtoW61zqTfX9H7tj"}],"time":"2018-12-03T14:39:47.162Z","expires":"2018-12-03T14:54:47.162Z","memo":"Payment request for BitPay invoice HHfG8cprRMzZG6MErCqbjv for merchant VULTR Holdings LLC","paymentUrl":"https://bitpay.com/i/HHfG8cprRMzZG6MErCqbjv","paymentId":"HHfG8cprRMzZG6MErCqbjv"}
+                var str = await result.Content.ReadAsStringAsync();
+                try
+                {
+                    var jobj = JObject.Parse(str);
+                    vm.Address = ((JArray)jobj["outputs"])[0]["address"].Value<string>();
+                    var amount = Money.Satoshis(((JArray)jobj["outputs"])[0]["amount"].Value<long>());
+                    vm.Amount = amount.ToString();
+                    vm.BitcoinUri = $"bitcoin:{vm.Address}?amount={amount.ToString()}";
+                }
+                catch (JsonReaderException)
+                {
+                    ModelState.AddModelError(nameof(vm.BitpayLink), $"Invalid or expired bitpay invoice");
+                    return View(vm);
+                }
+            }
+            catch (Exception ex)
+            {
+                ModelState.AddModelError(nameof(vm.BitpayLink), $"Error while requesting {ex.Message}");
+                return View(vm);
+            }
+            return View(vm);
+        }
+
         public IActionResult About()
         {
             ViewData["Message"] = "Your application description page.";

BTCPayServer/Controllers/InvoiceController.API.cs

@@ -1,121 +1,90 @@
-using BTCPayServer.Authentication;
-using Microsoft.Extensions.Logging;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using BTCPayServer.Filters;
-using BTCPayServer.Logging;
 using BTCPayServer.Models;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Invoices;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
 using NBitpayClient;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Data;
-using BTCPayServer.Servcices.Invoices;
 
 namespace BTCPayServer.Controllers
 {
-    public partial class InvoiceController
+    [BitpayAPIConstraint]
+    [Authorize(Policies.CanCreateInvoice.Key, AuthenticationSchemes = Policies.BitpayAuthentication)]
+    public class InvoiceControllerAPI : Controller
     {
-		[HttpPost]
-		[Route("invoices")]
-		[MediaTypeConstraint("application/json")]
-		[BitpayAPIConstraint]
-		public async Task<DataWrapper<InvoiceResponse>> CreateInvoice([FromBody] Invoice invoice)
-		{
-			var bitToken = await CheckTokenPermissionAsync(Facade.Merchant, invoice.Token);
-			var store = await FindStore(bitToken);
-			return await CreateInvoiceCore(invoice, store);
-		}
+        private InvoiceController _InvoiceController;
+        private InvoiceRepository _InvoiceRepository;
+        private BTCPayNetworkProvider _NetworkProvider;
 
-		[HttpGet]
-		[Route("invoices/{id}")]
-		[BitpayAPIConstraint]
-		public async Task<DataWrapper<InvoiceResponse>> GetInvoice(string id, string token)
-		{
-			var bitToken = await CheckTokenPermissionAsync(Facade.Merchant, token);
-			var store = await FindStore(bitToken);
-			var invoice = await _InvoiceRepository.GetInvoice(store.Id, id);
-			if(invoice == null)
-				throw new BitpayHttpException(404, "Object not found");
+        public InvoiceControllerAPI(InvoiceController invoiceController,
+                                    InvoiceRepository invoceRepository,
+                                    BTCPayNetworkProvider networkProvider)
+        {
+            this._InvoiceController = invoiceController;
+            this._InvoiceRepository = invoceRepository;
+            this._NetworkProvider = networkProvider;
+        }
 
-			var resp = invoice.EntityToDTO();
-			return new DataWrapper<InvoiceResponse>(resp);
-		}
+        [HttpPost]
+        [Route("invoices")]
+        [MediaTypeConstraint("application/json")]
+        public async Task<DataWrapper<InvoiceResponse>> CreateInvoice([FromBody] CreateInvoiceRequest invoice, CancellationToken cancellationToken)
+        {
+            if (invoice == null)
+                throw new BitpayHttpException(400, "Invalid invoice");
+            return await _InvoiceController.CreateInvoiceCore(invoice, HttpContext.GetStoreData(), HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
+        }
 
-		[HttpGet]
-		[Route("invoices")]
-		[BitpayAPIConstraint]
-		public async Task<DataWrapper<InvoiceResponse[]>> GetInvoices(
-			string token,
-			DateTimeOffset? dateStart = null,
-			DateTimeOffset? dateEnd = null,
-			string orderId = null,
-			string itemCode = null,
-			string status = null,
-			int? limit = null,
-			int? offset = null)
-		{
-			if(dateEnd != null)
-				dateEnd = dateEnd.Value + TimeSpan.FromDays(1); //Should include the end day
-			var bitToken = await CheckTokenPermissionAsync(Facade.Merchant, token);
-			var store = await FindStore(bitToken);
-			var query = new InvoiceQuery()
-			{
-				Count = limit,
-				Skip = offset,
-				EndDate = dateEnd,
-				StartDate = dateStart,
-				OrderId = orderId,
-				ItemCode = itemCode,
-				Status = status,
-				StoreId = store.Id
-			};
+        [HttpGet]
+        [Route("invoices/{id}")]
+        public async Task<DataWrapper<InvoiceResponse>> GetInvoice(string id)
+        {
+            var invoice = (await _InvoiceRepository.GetInvoices(new InvoiceQuery()
+            {
+                InvoiceId = id,
+                StoreId = new[] { HttpContext.GetStoreData().Id }
+            })).FirstOrDefault();
+            if (invoice == null)
+                throw new BitpayHttpException(404, "Object not found");
+            var resp = invoice.EntityToDTO(_NetworkProvider);
+            return new DataWrapper<InvoiceResponse>(resp);
+        }
+        [HttpGet]
+        [Route("invoices")]
+        public async Task<DataWrapper<InvoiceResponse[]>> GetInvoices(
+            string token,
+            DateTimeOffset? dateStart = null,
+            DateTimeOffset? dateEnd = null,
+            string orderId = null,
+            string itemCode = null,
+            string status = null,
+            int? limit = null,
+            int? offset = null)
+        {
+            if (dateEnd != null)
+                dateEnd = dateEnd.Value + TimeSpan.FromDays(1); //Should include the end day
 
+            var query = new InvoiceQuery()
+            {
+                Count = limit,
+                Skip = offset,
+                EndDate = dateEnd,
+                StartDate = dateStart,
+                OrderId =  orderId == null ? null : new[] { orderId },
+                ItemCode =  itemCode == null ? null : new[] { itemCode },
+                Status = status == null ? null : new[] { status },
+                StoreId = new[] { this.HttpContext.GetStoreData().Id }
+            };
 
-			var entities = (await _InvoiceRepository.GetInvoices(query))
-							.Select((o) => o.EntityToDTO()).ToArray();
+            var entities = (await _InvoiceRepository.GetInvoices(query))
+                            .Select((o) => o.EntityToDTO(_NetworkProvider)).ToArray();
 
-			return DataWrapper.Create(entities);
-		}
-
-		private async Task<BitTokenEntity> CheckTokenPermissionAsync(Facade facade, string expectedToken)
-		{
-			if(facade == null)
-				throw new ArgumentNullException(nameof(facade));
-
-			var actualTokens = (await _TokenRepository.GetTokens(this.GetBitIdentity().SIN)).Where(t => t.Active).ToArray();
-			actualTokens = actualTokens.SelectMany(t => GetCompatibleTokens(t)).ToArray();
-			
-			var actualToken = actualTokens.FirstOrDefault(a => a.Value.Equals(expectedToken, StringComparison.Ordinal));
-			if(expectedToken == null || actualToken == null)
-			{
-				Logs.PayServer.LogDebug($"No token found for facade {facade} for SIN {this.GetBitIdentity().SIN}");
-				throw new BitpayHttpException(401, $"This endpoint does not support the `{actualTokens.Select(a => a.Name).Concat(new[] { "user" }).FirstOrDefault()}` facade");
-			}
-			return actualToken;
-		}
-
-		private IEnumerable<BitTokenEntity> GetCompatibleTokens(BitTokenEntity token)
-		{
-			if(token.Name == Facade.Merchant.ToString())
-			{
-				yield return token.Clone(Facade.User);
-				yield return token.Clone(Facade.PointOfSale);
-			}
-			if(token.Name == Facade.PointOfSale.ToString())
-			{
-				yield return token.Clone(Facade.User);
-			}
-			yield return token;
-		}
-
-		private async Task<StoreData> FindStore(BitTokenEntity bitToken)
-		{
-			var store = await _StoreRepository.FindStore(bitToken.PairedId);
-			if(store == null)
-				throw new BitpayHttpException(401, "Unknown store");
-			return store;
-		}
-
-	}
+            return DataWrapper.Create(entities);
+        }
+    }
 }

BTCPayServer/Controllers/InvoiceController.PaymentProtocol.cs

@@ -1,72 +0,0 @@
-using BTCPayServer.Filters;
-using Microsoft.Extensions.Logging;
-using BTCPayServer.Logging;
-using Microsoft.AspNetCore.Mvc;
-using NBitcoin;
-using NBitcoin.Payment;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Controllers
-{
-    public partial class InvoiceController
-    {
-		[HttpGet]
-		[Route("i/{invoiceId}")]
-		[AcceptMediaTypeConstraint("application/bitcoin-paymentrequest")]
-		public async Task<IActionResult> GetInvoiceRequest(string invoiceId)
-		{
-			var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-			if(invoice == null || invoice.IsExpired())
-				return NotFound();
-
-			var dto = invoice.EntityToDTO();
-			PaymentRequest request = new PaymentRequest
-			{
-				DetailsVersion = 1
-			};
-			request.Details.Expires = invoice.ExpirationTime;
-			request.Details.Memo = invoice.ProductInformation.ItemDesc;
-			request.Details.Network = _Network;
-			request.Details.Outputs.Add(new PaymentOutput() { Amount = dto.BTCDue, Script = BitcoinAddress.Create(dto.BitcoinAddress, _Network).ScriptPubKey });
-			request.Details.MerchantData = Encoding.UTF8.GetBytes(invoice.Id);
-			request.Details.Time = DateTimeOffset.UtcNow;
-			request.Details.PaymentUrl = new Uri(invoice.ServerUrl.WithTrailingSlash() + ($"i/{invoice.Id}"), UriKind.Absolute);
-
-			var store = await _StoreRepository.FindStore(invoice.StoreId);
-			if(store == null)
-				throw new BitpayHttpException(401, "Unknown store");
-
-			if(store.StoreCertificate != null)
-			{
-				try
-				{
-					request.Sign(store.StoreCertificate, PKIType.X509SHA256);
-				}
-				catch(Exception ex)
-				{
-					Logs.PayServer.LogWarning(ex, "Error while signing payment request");
-				}
-			}
-
-			return new PaymentRequestActionResult(request);
-		}
-
-		[HttpPost]
-		[Route("i/{invoiceId}", Order = 99)]
-		[MediaTypeConstraint("application/bitcoin-payment")]
-		public async Task<IActionResult> PostPayment(string invoiceId)
-		{
-			var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-			if(invoice == null || invoice.IsExpired())
-				return NotFound();
-			var payment = PaymentMessage.Load(Request.Body);
-			var unused = _Wallet.BroadcastTransactionsAsync(payment.Transactions);
-			await _InvoiceRepository.AddRefundsAsync(invoiceId, payment.RefundTo.Select(p => new TxOut(p.Amount, p.Script)).ToArray());
-			return new PaymentAckActionResult(payment.CreateACK(invoiceId + " is currently processing, thanks for your purchase..."));
-		}
-	}
-}

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -1,206 +1,767 @@
-using BTCPayServer.Data;
-using BTCPayServer.Filters;
-using BTCPayServer.Models.InvoicingModels;
-using BTCPayServer.Servcices.Invoices;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Rendering;
-using NBitcoin;
-using NBitpayClient;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Security.Claims;
-using System.Text;
+using System.Net.Mime;
+using System.Net.WebSockets;
+using System.Threading;
 using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.Filters;
+using BTCPayServer.Models;
+using BTCPayServer.Models.InvoicingModels;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.CoinSwitch;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Invoices.Export;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.EntityFrameworkCore.Internal;
+using NBitcoin;
+using NBitpayClient;
+using NBXplorer;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Controllers
 {
     public partial class InvoiceController
     {
+        [HttpGet]
+        [Route("invoices/{invoiceId}")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        public async Task<IActionResult> Invoice(string invoiceId)
+        {
+            var invoice = (await _InvoiceRepository.GetInvoices(new InvoiceQuery()
+            {
+                InvoiceId = invoiceId,
+                UserId = GetUserId(),
+                IncludeAddresses = true,
+                IncludeEvents = true
+            })).FirstOrDefault();
+            if (invoice == null)
+                return NotFound();
 
-		[HttpGet]
-		[Route("i/{invoiceId}")]
-		[AcceptMediaTypeConstraint("application/bitcoin-paymentrequest", false)]
-		public async Task<IActionResult> Checkout(string invoiceId)
-		{
-			var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-			if(invoice == null)
-				return NotFound();
-			var store = await _StoreRepository.FindStore(invoice.StoreId);
-			var dto = invoice.EntityToDTO();
+            var prodInfo = invoice.ProductInformation;
+            var store = await _StoreRepository.FindStore(invoice.StoreId);
+            var model = new InvoiceDetailsModel()
+            {
+                StoreName = store.StoreName,
+                StoreLink = Url.Action(nameof(StoresController.UpdateStore), "Stores", new { storeId = store.Id }),
+                Id = invoice.Id,
+                State = invoice.GetInvoiceState().ToString(),
+                TransactionSpeed = invoice.SpeedPolicy == SpeedPolicy.HighSpeed ? "high" :
+                                   invoice.SpeedPolicy == SpeedPolicy.MediumSpeed ? "medium" :
+                                   invoice.SpeedPolicy == SpeedPolicy.LowMediumSpeed ? "low-medium" :
+                                   "low",
+                RefundEmail = invoice.RefundMail,
+                CreatedDate = invoice.InvoiceTime,
+                ExpirationDate = invoice.ExpirationTime,
+                MonitoringDate = invoice.MonitoringExpiration,
+                OrderId = invoice.OrderId,
+                BuyerInformation = invoice.BuyerInformation,
+                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(invoice.PosData),
+                StatusMessage = StatusMessage
+            };
 
-			var model = new PaymentModel()
-			{
-				OrderId = invoice.OrderId,
-				InvoiceId = invoice.Id,
-				BTCAddress = invoice.DepositAddress.ToString(),
-				BTCAmount = (invoice.GetTotalCryptoDue() - invoice.TxFee).ToString(),
-				BTCTotalDue = invoice.GetTotalCryptoDue().ToString(),
-				BTCDue = invoice.GetCryptoDue().ToString(),
-				CustomerEmail = invoice.RefundMail,
-				ExpirationSeconds = Math.Max(0, (int)(invoice.ExpirationTime - DateTimeOffset.UtcNow).TotalSeconds),
-				MaxTimeSeconds = (int)(invoice.ExpirationTime - invoice.InvoiceTime).TotalSeconds,
-				ItemDesc = invoice.ProductInformation.ItemDesc,
-				Rate = invoice.Rate.ToString(),
-				RedirectUrl = invoice.RedirectURL,
-				StoreName = store.StoreName,
-				TxFees = invoice.TxFee.ToString(),
-				InvoiceBitcoinUrl = dto.PaymentUrls.BIP72,
-				TxCount = invoice.GetTxCount(),
-				BTCPaid = invoice.GetTotalPaid().ToString(),
-				Status = invoice.Status
-			};
+            model.Addresses = invoice.HistoricalAddresses.Select(h => new InvoiceDetailsModel.AddressModel
+            {
+                Destination = h.GetAddress(),
+                PaymentMethod = ToString(h.GetPaymentMethodId()),
+                Current = !h.UnAssigned.HasValue
+            }).ToArray();
 
-			var expiration = TimeSpan.FromSeconds((double)model.ExpirationSeconds);
-			model.TimeLeft = PrettyPrint(expiration);
-			return View(model);
-		}
+            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);
 
-		private string PrettyPrint(TimeSpan expiration)
-		{
-			StringBuilder builder = new StringBuilder();
-			if(expiration.Days >= 1)
-				builder.Append(expiration.Days.ToString());
-			if(expiration.Hours >= 1)
-				builder.Append(expiration.Hours.ToString("00"));
-			builder.Append($"{expiration.Minutes.ToString("00")}:{expiration.Seconds.ToString("00")}");
-			return builder.ToString();
-		}
+            var details = InvoicePopulatePayments(invoice);
+            model.CryptoPayments = details.CryptoPayments;
+            model.OnChainPayments = details.OnChainPayments;
+            model.OffChainPayments = details.OffChainPayments;
 
-		[HttpGet]
-		[Route("i/{invoiceId}/status")]
-		public async Task<IActionResult> GetStatus(string invoiceId)
-		{
-			var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-			if(invoice == null)
-				return NotFound();
-			return Content(invoice.Status);
-		}
+            return View(model);
+        }
 
-		[HttpPost]
-		[Route("i/{invoiceId}/UpdateCustomer")]
-		public async Task<IActionResult> UpdateCustomer(string invoiceId, [FromBody]UpdateCustomerModel data)
-		{
-			if(!ModelState.IsValid)
-			{
-				return BadRequest(ModelState);
-			}
-			await _InvoiceRepository.UpdateInvoice(invoiceId, data).ConfigureAwait(false);
-			return Ok();
-		}
+        private InvoiceDetailsModel InvoicePopulatePayments(InvoiceEntity invoice)
+        {
+            var model = new InvoiceDetailsModel();
 
-		[HttpGet]
-		[Route("invoices")]
-		[Authorize(AuthenticationSchemes = "Identity.Application")]
-		[BitpayAPIConstraint(false)]
-		public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 20)
-		{
-			var model = new InvoicesModel();
-			foreach(var invoice in await _InvoiceRepository.GetInvoices(new InvoiceQuery()
-			{
-				TextSearch = searchTerm,
-				Count = count,
-				Skip = skip,
-				UserId = GetUserId()
-			}))
-			{
-				model.SearchTerm = searchTerm;
-				model.Invoices.Add(new InvoiceModel()
-				{
-					Status = invoice.Status,
-					Date = invoice.InvoiceTime,
-					InvoiceId = invoice.Id,
-					AmountCurrency = $"{invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture)} {invoice.ProductInformation.Currency}"
-				});
-			}
-			model.Skip = skip;
-			model.Count = count;
-			model.StatusMessage = StatusMessage;
-			return View(model);
-		}
+            foreach (var data in invoice.GetPaymentMethods(null))
+            {
+                var accounting = data.Calculate();
+                var paymentMethodId = data.GetId();
+                var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
+                cryptoPayment.PaymentMethod = ToString(paymentMethodId);
+                cryptoPayment.Due = _CurrencyNameTable.DisplayFormatCurrency(accounting.Due.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
+                cryptoPayment.Paid = _CurrencyNameTable.DisplayFormatCurrency(accounting.CryptoPaid.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
+                cryptoPayment.Overpaid = _CurrencyNameTable.DisplayFormatCurrency(accounting.OverpaidHelper.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
 
-		[HttpGet]
-		[Route("invoices/create")]
-		[Authorize(AuthenticationSchemes = "Identity.Application")]
-		[BitpayAPIConstraint(false)]
-		public async Task<IActionResult> CreateInvoice()
-		{
-			var stores = await GetStores(GetUserId());
-			if(stores.Count() == 0)
-			{
-				StatusMessage = "Error: You need to create at least one store before creating a transaction";
-				return RedirectToAction(nameof(StoresController.ListStores), "Stores");
-			}
-			return View(new CreateInvoiceModel() { Stores = stores });
-		}
+                var onchainMethod = data.GetPaymentMethodDetails() as Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod;
+                if (onchainMethod != null)
+                {
+                    cryptoPayment.Address = onchainMethod.DepositAddress;
+                }
+                cryptoPayment.Rate = ExchangeRate(data);
+                model.CryptoPayments.Add(cryptoPayment);
+            }
 
-		[HttpPost]
-		[Route("invoices/create")]
-		[Authorize(AuthenticationSchemes = "Identity.Application")]
-		[BitpayAPIConstraint(false)]
-		public async Task<IActionResult> CreateInvoice(CreateInvoiceModel model)
-		{
-			if(!ModelState.IsValid)
-			{
-				model.Stores = await GetStores(GetUserId(), model.StoreId);
-				return View(model);
-			}
-			var store = await _StoreRepository.FindStore(model.StoreId, GetUserId());
-			if(string.IsNullOrEmpty(store.DerivationStrategy))
-			{
-				StatusMessage = "Error: You need to configure the derivation scheme in order to create an invoice";
-				return RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
-				{
-					storeId = store.Id
-				});
-			}
-			var result = await CreateInvoiceCore(new Invoice()
-			{
-				Price = model.Amount.Value,
-				Currency = "USD",
-				PosData = model.PosData,
-				OrderId = model.OrderId,
-				//RedirectURL = redirect + "redirect",
-				NotificationURL = model.NotificationUrl,
-				ItemDesc = model.ItemDesc,
-				FullNotifications = true,
-				BuyerEmail = model.BuyerEmail,
-			}, store);
-			
-			StatusMessage = $"Invoice {result.Data.Id} just created!";
-			return RedirectToAction(nameof(ListInvoices));
-		}
+            foreach (var payment in invoice.GetPayments())
+            {
+                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);
 
-		private async Task<SelectList> GetStores(string userId, string storeId = null)
-		{
-			return new	SelectList(await _StoreRepository.GetStoresByUserId(userId), nameof(StoreData.Id), nameof(StoreData.StoreName), storeId);
-		}
+                    int confirmationCount = onChainPaymentData.ConfirmationCount;
+                    if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
+                    {
+                        m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
+                    }
+                    else
+                    {
+                        m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
+                    }
 
-		[HttpPost]
-		[Authorize(AuthenticationSchemes = "Identity.Application")]
-		[BitpayAPIConstraint(false)]
-		public IActionResult SearchInvoice(InvoicesModel invoices)
-		{
-			return RedirectToAction(nameof(ListInvoices), new
-			{
-				searchTerm = invoices.SearchTerm,
-				skip = invoices.Skip,
-				count = invoices.Count,
-			});
-		}
+                    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;
+        }
 
-		[TempData]
-		public string StatusMessage
-		{
-			get;
-			set;
-		}
+        private string ToString(PaymentMethodId paymentMethodId)
+        {
+            var type = paymentMethodId.PaymentType.ToString();
+            switch (paymentMethodId.PaymentType)
+            {
+                case PaymentTypes.BTCLike:
+                    type = "On-Chain";
+                    break;
+                case PaymentTypes.LightningLike:
+                    type = "Off-Chain";
+                    break;
+            }
+            return $"{paymentMethodId.CryptoCode} ({type})";
+        }
 
-		private string GetUserId()
-		{
-			return _UserManager.GetUserId(User);
-		}
-	}
+        [HttpGet]
+        [Route("i/{invoiceId}")]
+        [Route("i/{invoiceId}/{paymentMethodId}")]
+        [Route("invoice")]
+        [AcceptMediaTypeConstraint("application/bitcoin-paymentrequest", false)]
+        [XFrameOptionsAttribute(null)]
+        [ReferrerPolicyAttribute("origin")]
+        public async Task<IActionResult> Checkout(string invoiceId, string id = null, string paymentMethodId = null,
+            [FromQuery]string view = null)
+        {
+            //Keep compatibility with Bitpay
+            invoiceId = invoiceId ?? id;
+            id = invoiceId;
+            //
+
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
+            if (model == null)
+                return NotFound();
+
+            if (view == "modal")
+                model.IsModal = true;
+
+            _CSP.Add(new ConsentSecurityPolicy("script-src", "'unsafe-eval'")); // Needed by Vue
+            if (!string.IsNullOrEmpty(model.CustomCSSLink) &&
+                Uri.TryCreate(model.CustomCSSLink, UriKind.Absolute, out var uri))
+            {
+                _CSP.Clear();
+            }
+
+            if (!string.IsNullOrEmpty(model.CustomLogoLink) &&
+                Uri.TryCreate(model.CustomLogoLink, UriKind.Absolute, out uri))
+            {
+                _CSP.Clear();
+            }
+
+            return View(nameof(Checkout), model);
+        }
+
+        [HttpGet]
+        [Route("invoice-noscript")]
+        public async Task<IActionResult> CheckoutNoScript(string invoiceId, string id = null, string paymentMethodId = null)
+        {
+            //Keep compatibility with Bitpay
+            invoiceId = invoiceId ?? id;
+            id = invoiceId;
+            //
+
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
+            if (model == null)
+                return NotFound();
+
+            return View(model);
+        }
+
+
+        private async Task<PaymentModel> GetInvoiceModel(string invoiceId, PaymentMethodId paymentMethodId)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
+            if (invoice == null)
+                return null;
+            var store = await _StoreRepository.FindStore(invoice.StoreId);
+            bool isDefaultPaymentId = false;
+            if (paymentMethodId == null)
+            {
+                paymentMethodId = store.GetDefaultPaymentId(_NetworkProvider);
+                isDefaultPaymentId = true;
+            }
+            var network = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode);
+            if (network == null && isDefaultPaymentId)
+            {
+                network = _NetworkProvider.GetAll().FirstOrDefault();
+                paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
+            }
+            if (invoice == null || network == null)
+                return null;
+            if (!invoice.Support(paymentMethodId))
+            {
+                if (!isDefaultPaymentId)
+                    return null;
+                var paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider)
+                                               .Where(c => paymentMethodId.CryptoCode == c.GetId().CryptoCode)
+                                               .FirstOrDefault();
+                if (paymentMethodTemp == null)
+                    paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider).First();
+                network = paymentMethodTemp.Network;
+                paymentMethodId = paymentMethodTemp.GetId();
+            }
+
+            var paymentMethod = invoice.GetPaymentMethod(paymentMethodId, _NetworkProvider);
+            var paymentMethodDetails = paymentMethod.GetPaymentMethodDetails();
+            var dto = invoice.EntityToDTO(_NetworkProvider);
+            var cryptoInfo = dto.CryptoInfo.First(o => o.GetpaymentMethodId() == paymentMethodId);
+            var storeBlob = store.GetStoreBlob();
+            var currency = invoice.ProductInformation.Currency;
+            var accounting = paymentMethod.Calculate();
+
+            ChangellySettings changelly = (storeBlob.ChangellySettings != null && storeBlob.ChangellySettings.Enabled &&
+                                           storeBlob.ChangellySettings.IsConfigured())
+                ? storeBlob.ChangellySettings
+                : null;
+
+            CoinSwitchSettings coinswitch = (storeBlob.CoinSwitchSettings != null && storeBlob.CoinSwitchSettings.Enabled &&
+                                           storeBlob.CoinSwitchSettings.IsConfigured())
+                ? storeBlob.CoinSwitchSettings
+                : null;
+
+
+            var changellyAmountDue = changelly != null
+                ? (accounting.Due.ToDecimal(MoneyUnit.BTC) *
+                   (1m + (changelly.AmountMarkupPercentage / 100m)))
+                : (decimal?)null;
+
+            var model = new PaymentModel()
+            {
+                CryptoCode = network.CryptoCode,
+                RootPath = this.Request.PathBase.Value.WithTrailingSlash(),
+                PaymentMethodId = paymentMethodId.ToString(),
+                PaymentMethodName = GetDisplayName(paymentMethodId, network),
+                CryptoImage = GetImage(paymentMethodId, network),
+                IsLightning = paymentMethodId.PaymentType == PaymentTypes.LightningLike,
+                OrderId = invoice.OrderId,
+                InvoiceId = invoice.Id,
+                DefaultLang = storeBlob.DefaultLang ?? "en",
+                HtmlTitle = storeBlob.HtmlTitle ?? "BTCPay Invoice",
+                CustomCSSLink = storeBlob.CustomCSS?.AbsoluteUri,
+                CustomLogoLink = storeBlob.CustomLogo?.AbsoluteUri,
+                LightningAmountInSatoshi = storeBlob.LightningAmountInSatoshi,
+                BtcAddress = paymentMethodDetails.GetPaymentDestination(),
+                BtcDue = accounting.Due.ToString(),
+                OrderAmount = (accounting.TotalDue - accounting.NetworkFee).ToString(),
+                OrderAmountFiat = OrderAmountFromInvoice(network.CryptoCode, invoice.ProductInformation),
+                CustomerEmail = invoice.RefundMail,
+                RequiresRefundEmail = storeBlob.RequiresRefundEmail,
+                ExpirationSeconds = Math.Max(0, (int)(invoice.ExpirationTime - DateTimeOffset.UtcNow).TotalSeconds),
+                MaxTimeSeconds = (int)(invoice.ExpirationTime - invoice.InvoiceTime).TotalSeconds,
+                MaxTimeMinutes = (int)(invoice.ExpirationTime - invoice.InvoiceTime).TotalMinutes,
+                ItemDesc = invoice.ProductInformation.ItemDesc,
+                Rate = ExchangeRate(paymentMethod),
+                MerchantRefLink = invoice.RedirectURL ?? "/",
+                RedirectAutomatically = invoice.RedirectAutomatically,
+                StoreName = store.StoreName,
+                InvoiceBitcoinUrl = paymentMethodId.PaymentType == PaymentTypes.BTCLike ? cryptoInfo.PaymentUrls.BIP21 :
+                                    paymentMethodId.PaymentType == PaymentTypes.LightningLike ? cryptoInfo.PaymentUrls.BOLT11 :
+                                    throw new NotSupportedException(),
+                PeerInfo = (paymentMethodDetails as LightningLikePaymentMethodDetails)?.NodeInfo,
+                InvoiceBitcoinUrlQR = paymentMethodId.PaymentType == PaymentTypes.BTCLike ? cryptoInfo.PaymentUrls.BIP21 :
+                                    paymentMethodId.PaymentType == PaymentTypes.LightningLike ? cryptoInfo.PaymentUrls.BOLT11.ToUpperInvariant() :
+                                    throw new NotSupportedException(),
+                TxCount = accounting.TxRequired,
+                BtcPaid = accounting.Paid.ToString(),
+#pragma warning disable CS0618 // Type or member is obsolete
+                Status = invoice.StatusString,
+#pragma warning restore CS0618 // Type or member is obsolete
+                NetworkFee = paymentMethodDetails.GetNextNetworkFee(),
+                IsMultiCurrency = invoice.GetPayments().Select(p => p.GetPaymentMethodId()).Concat(new[] { paymentMethod.GetId() }).Distinct().Count() > 1,
+                ChangellyEnabled = changelly != null,
+                ChangellyMerchantId = changelly?.ChangellyMerchantId,
+                ChangellyAmountDue = changellyAmountDue,
+                CoinSwitchEnabled = coinswitch != null,
+                CoinSwitchAmountMarkupPercentage = coinswitch?.AmountMarkupPercentage ?? 0,
+                CoinSwitchMerchantId = coinswitch?.MerchantId,
+                CoinSwitchMode = coinswitch?.Mode,
+                StoreId = store.Id,
+                AvailableCryptos = invoice.GetPaymentMethods(_NetworkProvider)
+                                          .Where(i => i.Network != null)
+                                          .Select(kv => new PaymentModel.AvailableCrypto()
+                                          {
+                                              PaymentMethodId = kv.GetId().ToString(),
+                                              CryptoCode = kv.GetId().CryptoCode,
+                                              PaymentMethodName = GetDisplayName(kv.GetId(), kv.Network),
+                                              IsLightning = kv.GetId().PaymentType == PaymentTypes.LightningLike,
+                                              CryptoImage = GetImage(kv.GetId(), kv.Network),
+                                              Link = Url.Action(nameof(Checkout), new { invoiceId = invoiceId, paymentMethodId = kv.GetId().ToString() })
+                                          }).Where(c => c.CryptoImage != "/")
+                                          .OrderByDescending(a => a.CryptoCode == "BTC").ThenBy(a => a.PaymentMethodName).ThenBy(a => a.IsLightning ? 1 : 0)
+                                          .ToList()
+            };
+
+            var expiration = TimeSpan.FromSeconds(model.ExpirationSeconds);
+            model.TimeLeft = expiration.PrettyPrint();
+            return model;
+        }
+
+        private string GetDisplayName(PaymentMethodId paymentMethodId, BTCPayNetwork network)
+        {
+            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
+                network.DisplayName : network.DisplayName + " (Lightning)";
+        }
+
+        private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
+        {
+            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
+                this.Request.GetRelativePathOrAbsolute(network.CryptoImagePath) : this.Request.GetRelativePathOrAbsolute(network.LightningImagePath);
+        }
+
+        private string OrderAmountFromInvoice(string cryptoCode, ProductInformation productInformation)
+        {
+            // if invoice source currency is the same as currently display currency, no need for "order amount from invoice"
+            if (cryptoCode == productInformation.Currency)
+                return null;
+
+            return _CurrencyNameTable.DisplayFormatCurrency(productInformation.Price, productInformation.Currency);
+        }
+        private string ExchangeRate(PaymentMethod paymentMethod)
+        {
+            string currency = paymentMethod.ParentEntity.ProductInformation.Currency;
+            return _CurrencyNameTable.DisplayFormatCurrency(paymentMethod.Rate, currency);
+        }
+
+        [HttpGet]
+        [Route("i/{invoiceId}/status")]
+        [Route("i/{invoiceId}/{paymentMethodId}/status")]
+        [Route("invoice/{invoiceId}/status")]
+        [Route("invoice/{invoiceId}/{paymentMethodId}/status")]
+        [Route("invoice/status")]
+        public async Task<IActionResult> GetStatus(string invoiceId, string paymentMethodId = null)
+        {
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId == null ? null : PaymentMethodId.Parse(paymentMethodId));
+            if (model == null)
+                return NotFound();
+            return Json(model);
+        }
+
+        [HttpGet]
+        [Route("i/{invoiceId}/status/ws")]
+        [Route("i/{invoiceId}/{paymentMethodId}/status/ws")]
+        [Route("invoice/{invoiceId}/status/ws")]
+        [Route("invoice/{invoiceId}/{paymentMethodId}/status")]
+        [Route("invoice/status/ws")]
+        public async Task<IActionResult> GetStatusWebSocket(string invoiceId)
+        {
+            if (!HttpContext.WebSockets.IsWebSocketRequest)
+                return NotFound();
+            var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
+            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();
+            try
+            {
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceNewAddressEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async o => await NotifySocket(webSocket, o.Invoice.Id, invoiceId)));
+                while (true)
+                {
+                    var message = await webSocket.ReceiveAsync(DummyBuffer, default(CancellationToken));
+                    if (message.MessageType == WebSocketMessageType.Close)
+                        break;
+                }
+            }
+            finally
+            {
+                leases.Dispose();
+                await webSocket.CloseSocket();
+            }
+            return new EmptyResult();
+        }
+
+        ArraySegment<Byte> DummyBuffer = new ArraySegment<Byte>(new Byte[1]);
+        private async Task NotifySocket(WebSocket webSocket, string invoiceId, string expectedId)
+        {
+            if (invoiceId != expectedId || webSocket.State != WebSocketState.Open)
+                return;
+            CancellationTokenSource cts = new CancellationTokenSource();
+            cts.CancelAfter(5000);
+            try
+            {
+                await webSocket.SendAsync(DummyBuffer, WebSocketMessageType.Binary, true, cts.Token);
+            }
+            catch { try { webSocket.Dispose(); } catch { } }
+        }
+
+        [HttpPost]
+        [Route("i/{invoiceId}/UpdateCustomer")]
+        [Route("invoice/UpdateCustomer")]
+        public async Task<IActionResult> UpdateCustomer(string invoiceId, [FromBody]UpdateCustomerModel data)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+            await _InvoiceRepository.UpdateInvoice(invoiceId, data).ConfigureAwait(false);
+            return Ok("{}");
+        }
+
+        [HttpGet]
+        [Route("invoices")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 50, int timezoneOffset = 0)
+        {
+            var model = new InvoicesModel
+            {
+                SearchTerm = searchTerm,
+                Skip = skip,
+                Count = count,
+                StatusMessage = StatusMessage,
+                TimezoneOffset = timezoneOffset
+            };
+            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 = invoice.Status,
+                    StatusString = state.ToString(),
+                    ShowCheckout = invoice.Status == InvoiceStatus.New,
+                    Date = invoice.InvoiceTime,
+                    InvoiceId = invoice.Id,
+                    OrderId = invoice.OrderId ?? string.Empty,
+                    RedirectUrl = invoice.RedirectURL ?? string.Empty,
+                    AmountCurrency = _CurrencyNameTable.DisplayFormatCurrency(invoice.ProductInformation.Price, invoice.ProductInformation.Currency),
+                    CanMarkInvalid = state.CanMarkInvalid(),
+                    CanMarkComplete = state.CanMarkComplete(),
+                    Details = InvoicePopulatePayments(invoice)
+                });
+            }
+            model.Total = await counting;
+            return View(model);
+        }
+
+        private InvoiceQuery GetInvoiceQuery(string searchTerm = null, int timezoneOffset = 0)
+        {
+            var fs = new SearchString(searchTerm);
+            var invoiceQuery = new InvoiceQuery()
+            {
+                TextSearch = fs.TextSearch,
+                UserId = GetUserId(),
+                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;
+        }
+
+        [HttpGet]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> Export(string format, string searchTerm = null, int timezoneOffset = 0)
+        {
+            var model = new InvoiceExport(_NetworkProvider, _CurrencyNameTable);
+
+            InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm, timezoneOffset);
+            invoiceQuery.Skip = 0;
+            invoiceQuery.Count = int.MaxValue;
+            var invoices = await _InvoiceRepository.GetInvoices(invoiceQuery);
+            var res = model.Process(invoices, format);
+
+            var cd = new ContentDisposition
+            {
+                FileName = $"btcpay-export-{DateTime.UtcNow.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture)}.{format}",
+                Inline = true
+            };
+            Response.Headers.Add("Content-Disposition", cd.ToString());
+            Response.Headers.Add("X-Content-Type-Options", "nosniff");
+            return Content(res, "application/" + format);
+        }
+
+
+
+        [HttpGet]
+        [Route("invoices/create")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> CreateInvoice()
+        {
+            var stores = new SelectList(await _StoreRepository.GetStoresByUserId(GetUserId()), nameof(StoreData.Id), nameof(StoreData.StoreName), null);
+            if (stores.Count() == 0)
+            {
+                StatusMessage = "Error: You need to create at least one store before creating a transaction";
+                return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
+            }
+
+            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]
+        [Route("invoices/create")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> CreateInvoice(CreateInvoiceModel model, CancellationToken cancellationToken)
+        {
+            var stores = await _StoreRepository.GetStoresByUserId(GetUserId());
+            model.Stores = new SelectList(stores, nameof(StoreData.Id), nameof(StoreData.StoreName), model.StoreId);
+
+            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)
+            {
+                ModelState.AddModelError(nameof(model.StoreId), "Store not found");
+            }
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+            StatusMessage = null;
+            if (!store.HasClaim(Policies.CanCreateInvoice.Key))
+            {
+                ModelState.AddModelError(nameof(model.StoreId), "You need to be owner of this store to create an invoice");
+                return View(model);
+            }
+
+            if (store.GetSupportedPaymentMethods(_NetworkProvider).Count() == 0)
+            {
+                ModelState.AddModelError(nameof(model.StoreId), "You need to configure the derivation scheme in order to create an invoice");
+                return View(model);
+            }
+
+
+            if (StatusMessage != null)
+            {
+                return RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
+                {
+                    storeId = store.Id
+                });
+            }
+
+            try
+            {
+                var result = await CreateInvoiceCore(new CreateInvoiceRequest()
+                {
+                    Price = model.Amount.Value,
+                    Currency = model.Currency,
+                    PosData = model.PosData,
+                    OrderId = model.OrderId,
+                    //RedirectURL = redirect + "redirect",
+                    NotificationEmail = model.NotificationEmail,
+                    NotificationURL = model.NotificationUrl,
+                    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!";
+                return RedirectToAction(nameof(ListInvoices));
+            }
+            catch (BitpayHttpException ex)
+            {
+                ModelState.TryAddModelError(nameof(model.Currency), $"Error: {ex.Message}");
+                return View(model);
+            }
+        }
+
+        [HttpPost]
+        [Route("invoices/{invoiceId}/changestate/{newState}")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        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)
+            {
+                model.NotFound = true;
+                return NotFound(model);
+            }
+
+
+            if (newState == "invalid")
+            {
+                await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
+                _EventAggregator.Publish(new InvoiceEvent(invoice, 1008, InvoiceEvent.MarkedInvalid));
+                model.StatusString = new InvoiceState("invalid", "marked").ToString();
+            }
+            else if (newState == "complete")
+            {
+                await _InvoiceRepository.UpdatePaidInvoiceToComplete(invoiceId);
+                _EventAggregator.Publish(new InvoiceEvent(invoice, 2008, InvoiceEvent.MarkedCompleted));
+                model.StatusString = new InvoiceState("complete", "marked").ToString();
+            }
+
+            return Json(model);
+        }
+
+        public class InvoiceStateChangeModel
+        {
+            public bool NotFound { get; set; }
+            public string StatusString { get; set; }
+        }
+
+        [TempData]
+        public string StatusMessage
+        {
+            get;
+            set;
+        }
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+
+        public class PosDataParser
+        {
+            public static Dictionary<string, object> ParsePosData(string posData)
+            {
+                var result = new Dictionary<string, object>();
+                if (string.IsNullOrEmpty(posData))
+                {
+                    return result;
+                }
+
+                try
+                {
+                    var jObject = JObject.Parse(posData);
+                    foreach (var item in jObject)
+                    {
+
+                        switch (item.Value.Type)
+                        {
+                            case JTokenType.Array:
+                                var items = item.Value.AsEnumerable().ToList();
+                                for (var i = 0; i < items.Count(); i++)
+                                {
+                                    result.Add($"{item.Key}[{i}]", ParsePosData(items[i].ToString()));
+                                }
+                                break;
+                            case JTokenType.Object:
+                                result.Add(item.Key, ParsePosData(item.Value.ToString()));
+                                break;
+                            default:
+                                result.Add(item.Key, item.Value.ToString());
+                                break;
+                        }
+
+                    }
+                }
+                catch
+                {
+                    result.Add(string.Empty, posData);
+                }
+                return result;
+            }
+        }
+
+    }
 }

BTCPayServer/Controllers/InvoiceController.cs

@@ -1,113 +1,360 @@
-using BTCPayServer.Authentication;
-using System.Reflection;
-using System.Linq;
-using Microsoft.Extensions.Logging;
-using BTCPayServer.Logging;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using NBitpayClient;
-using System;
+using System;
 using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-using BTCPayServer.Models;
-using Newtonsoft.Json;
-using System.Globalization;
-using NBitcoin;
-using NBitcoin.DataEncoders;
-using BTCPayServer.Filters;
-using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
-using System.Net;
-using Microsoft.AspNetCore.Identity;
-using Newtonsoft.Json.Linq;
-using Microsoft.AspNetCore.Mvc.ModelBinding;
-using NBitcoin.Payment;
-using BTCPayServer.Data;
-using BTCPayServer.Models.InvoicingModels;
-using System.Security.Claims;
-using BTCPayServer.Services;
 using System.ComponentModel.DataAnnotations;
-using System.Text.RegularExpressions;
-using BTCPayServer.Services.Stores;
-using BTCPayServer.Servcices.Invoices;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.Logging;
+using BTCPayServer.Models;
+using BTCPayServer.Payments;
+using BTCPayServer.Rating;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
-using BTCPayServer.Validations;
-using Microsoft.AspNetCore.Mvc.Routing;
+using BTCPayServer.Validation;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using NBitcoin;
+using NBitpayClient;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Controllers
 {
-	public partial class InvoiceController : Controller
-	{
-		TokenRepository _TokenRepository;
-		InvoiceRepository _InvoiceRepository;
-		BTCPayWallet _Wallet;
-		IRateProvider _RateProvider;
-		private InvoiceWatcher _Watcher;
-		StoreRepository _StoreRepository;
-		Network _Network;
-		UserManager<ApplicationUser> _UserManager;
-		IFeeProvider _FeeProvider;
+    public partial class InvoiceController : Controller
+    {
+        InvoiceRepository _InvoiceRepository;
+        ContentSecurityPolicies _CSP;
+        RateFetcher _RateProvider;
+        StoreRepository _StoreRepository;
+        UserManager<ApplicationUser> _UserManager;
+        private CurrencyNameTable _CurrencyNameTable;
+        EventAggregator _EventAggregator;
+        BTCPayNetworkProvider _NetworkProvider;
+        private readonly BTCPayWalletProvider _WalletProvider;
+        IServiceProvider _ServiceProvider;
+        public InvoiceController(
+            IServiceProvider serviceProvider,
+            InvoiceRepository invoiceRepository,
+            CurrencyNameTable currencyNameTable,
+            UserManager<ApplicationUser> userManager,
+            RateFetcher rateProvider,
+            StoreRepository storeRepository,
+            EventAggregator eventAggregator,
+            BTCPayWalletProvider walletProvider,
+            ContentSecurityPolicies csp,
+            BTCPayNetworkProvider networkProvider)
+        {
+            _ServiceProvider = serviceProvider;
+            _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
+            _StoreRepository = storeRepository ?? throw new ArgumentNullException(nameof(storeRepository));
+            _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
+            _RateProvider = rateProvider ?? throw new ArgumentNullException(nameof(rateProvider));
+            _UserManager = userManager;
+            _EventAggregator = eventAggregator;
+            _NetworkProvider = networkProvider;
+            _WalletProvider = walletProvider;
+            _CSP = csp;
+        }
 
-		public InvoiceController(
-			Network network,
-			InvoiceRepository invoiceRepository,
-			UserManager<ApplicationUser> userManager,
-			TokenRepository tokenRepository,
-			BTCPayWallet wallet,
-			IRateProvider rateProvider,
-			StoreRepository storeRepository,
-			InvoiceWatcher watcher,
-			IFeeProvider feeProvider)
-		{
-			_StoreRepository = storeRepository ?? throw new ArgumentNullException(nameof(storeRepository));
-			_Network = network ?? throw new ArgumentNullException(nameof(network));
-			_TokenRepository = tokenRepository ?? throw new ArgumentNullException(nameof(tokenRepository));
-			_InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
-			_Wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
-			_RateProvider = rateProvider ?? throw new ArgumentNullException(nameof(rateProvider));
-			_Watcher = watcher ?? throw new ArgumentNullException(nameof(watcher));
-			_UserManager = userManager;
-			_FeeProvider = feeProvider ?? throw new ArgumentNullException(nameof(feeProvider));
-		}
 
-		private async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store)
-		{
-			var derivationStrategy = store.DerivationStrategy;
-			var entity = new InvoiceEntity
-			{
-				InvoiceTime = DateTimeOffset.UtcNow,
-				DerivationStrategy = derivationStrategy ?? throw new BitpayHttpException(400, "This store has not configured the derivation strategy")
-			};
-			Uri notificationUri = Uri.IsWellFormedUriString(invoice.NotificationURL, UriKind.Absolute) ? new Uri(invoice.NotificationURL, UriKind.Absolute) : null;
-			if(notificationUri == null || (notificationUri.Scheme != "http" && notificationUri.Scheme != "https")) //TODO: Filer non routable addresses ?
-				notificationUri = null;
-			EmailAddressAttribute emailValidator = new EmailAddressAttribute();
-			entity.ExpirationTime = entity.InvoiceTime + TimeSpan.FromMinutes(15.0);
-			entity.ServerUrl = HttpContext.Request.GetAbsoluteRoot();
-			entity.FullNotifications = invoice.FullNotifications;
-			entity.NotificationURL = notificationUri?.AbsoluteUri;
-			entity.BuyerInformation = Map<Invoice, BuyerInformation>(invoice);
-			entity.RefundMail = EmailValidator.IsEmail(entity?.BuyerInformation?.BuyerEmail) ? entity.BuyerInformation.BuyerEmail : null;
-			entity.ProductInformation = Map<Invoice, ProductInformation>(invoice);
-			entity.RedirectURL = invoice.RedirectURL ?? store.StoreWebsite;
-			entity.Status = "new";
-			entity.SpeedPolicy = store.SpeedPolicy;
-			entity.TxFee = (await _FeeProvider.GetFeeRateAsync()).GetFee(100); // assume price for 100 bytes
-			entity.Rate = (double)await _RateProvider.GetRateAsync(invoice.Currency);
-			entity.PosData = invoice.PosData;
-			entity.DepositAddress = await _Wallet.ReserveAddressAsync(derivationStrategy);
+        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(CreateInvoiceRequest invoice, StoreData store, string serverUrl, List<string> additionalTags = null, CancellationToken cancellationToken = default)
+        {
+            if (!store.HasClaim(Policies.CanCreateInvoice.Key))
+                throw new UnauthorizedAccessException();
+            InvoiceLogs logs = new InvoiceLogs();
+            logs.Write("Creation of invoice starting");
+            var entity = new InvoiceEntity
+            {
+                Version = InvoiceEntity.Lastest_Version,
+                InvoiceTime = DateTimeOffset.UtcNow
+            };
 
-			entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity);
-			await _Wallet.MapAsync(entity.DepositAddress, entity.Id);
-			await _Watcher.WatchAsync(entity.Id);
-			var resp = entity.EntityToDTO();
-			return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
-		}
+            var getAppsTaggingStore = _InvoiceRepository.GetAppsTaggingStore(store.Id);
+            var storeBlob = store.GetStoreBlob();
+            EmailAddressAttribute emailValidator = new EmailAddressAttribute();
+            entity.ExpirationTime = entity.InvoiceTime.AddMinutes(storeBlob.InvoiceExpiration);
+            entity.MonitoringExpiration = entity.ExpirationTime + TimeSpan.FromMinutes(storeBlob.MonitoringExpiration);
+            entity.OrderId = invoice.OrderId;
+            entity.ServerUrl = serverUrl;
+            entity.FullNotifications = invoice.FullNotifications || invoice.ExtendedNotifications;
+            entity.ExtendedNotifications = invoice.ExtendedNotifications;
+            
+            if (invoice.NotificationURL != null &&
+                Uri.TryCreate(invoice.NotificationURL, UriKind.Absolute, out var notificationUri) &&
+                (notificationUri.Scheme == "http" || notificationUri.Scheme == "https"))
+            {
+                entity.NotificationURL = notificationUri.AbsoluteUri;
+            }
+            entity.NotificationEmail = invoice.NotificationEmail;
+            entity.BuyerInformation = Map<CreateInvoiceRequest, BuyerInformation>(invoice);
+            entity.PaymentTolerance = storeBlob.PaymentTolerance;
+            if (additionalTags != null)
+                entity.InternalTags.AddRange(additionalTags);
+            //Another way of passing buyer info to support
+            FillBuyerInfo(invoice.Buyer, entity.BuyerInformation);
+            if (entity?.BuyerInformation?.BuyerEmail != null)
+            {
+                if (!EmailValidator.IsEmail(entity.BuyerInformation.BuyerEmail))
+                    throw new BitpayHttpException(400, "Invalid email");
+                entity.RefundMail = entity.BuyerInformation.BuyerEmail;
+            }
 
-		private TDest Map<TFrom, TDest>(TFrom data)
-		{
-			return JsonConvert.DeserializeObject<TDest>(JsonConvert.SerializeObject(data));
-		}
-	}
+            var taxIncluded = invoice.TaxIncluded.HasValue ? invoice.TaxIncluded.Value : 0m;
+
+            var currencyInfo = _CurrencyNameTable.GetNumberFormatInfo(invoice.Currency, false);
+            if (currencyInfo != null)
+            {
+                int divisibility = currencyInfo.CurrencyDecimalDigits;
+                invoice.Price = invoice.Price.RoundToSignificant(ref divisibility);
+                divisibility = currencyInfo.CurrencyDecimalDigits;
+                invoice.TaxIncluded = taxIncluded.RoundToSignificant(ref divisibility);
+            }
+            invoice.Price = Math.Max(0.0m, invoice.Price);
+            invoice.TaxIncluded = Math.Max(0.0m, taxIncluded);
+            invoice.TaxIncluded = Math.Min(taxIncluded, invoice.Price);
+
+            entity.ProductInformation = Map<CreateInvoiceRequest, ProductInformation>(invoice);
+
+
+            entity.RedirectURL = invoice.RedirectURL ?? store.StoreWebsite;
+            if (!Uri.IsWellFormedUriString(entity.RedirectURL, UriKind.Absolute))
+                entity.RedirectURL = null;
+
+            entity.RedirectAutomatically =
+                invoice.RedirectAutomatically.GetValueOrDefault(storeBlob.RedirectAutomatically);
+
+            entity.Status = InvoiceStatus.New;
+            entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
+
+            HashSet<CurrencyPair> currencyPairsToFetch = new HashSet<CurrencyPair>();
+            var rules = storeBlob.GetRateRules(_NetworkProvider);
+            var excludeFilter = storeBlob.GetExcludedPaymentMethods(); // Here we can compose filters from other origin with PaymentFilter.Any()
+
+            if (invoice.SupportedTransactionCurrencies != null && invoice.SupportedTransactionCurrencies.Count != 0)
+            {
+                var supportedTransactionCurrencies = invoice.SupportedTransactionCurrencies
+                                                            .Where(c => c.Value.Enabled)
+                                                            .Select(c => PaymentMethodId.TryParse(c.Key, out var p) ? p : null)
+                                                            .ToHashSet();
+                excludeFilter = PaymentFilter.Or(excludeFilter,
+                                                 PaymentFilter.Where(p => !supportedTransactionCurrencies.Contains(p)));
+            }
+
+            foreach (var network in store.GetSupportedPaymentMethods(_NetworkProvider)
+                                                .Where(s => !excludeFilter.Match(s.PaymentId))
+                                                .Select(c => _NetworkProvider.GetNetwork(c.PaymentId.CryptoCode))
+                                                .Where(c => c != null))
+            {
+                currencyPairsToFetch.Add(new CurrencyPair(network.CryptoCode, invoice.Currency));
+                if (storeBlob.LightningMaxValue != null)
+                    currencyPairsToFetch.Add(new CurrencyPair(network.CryptoCode, storeBlob.LightningMaxValue.Currency));
+                if (storeBlob.OnChainMinValue != null)
+                    currencyPairsToFetch.Add(new CurrencyPair(network.CryptoCode, storeBlob.OnChainMinValue.Currency));
+            }
+
+            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))
+                                               .Select(c =>
+                                                (Handler: (IPaymentMethodHandler)_ServiceProvider.GetService(typeof(IPaymentMethodHandler<>).MakeGenericType(c.GetType())),
+                                                SupportedPaymentMethod: c,
+                                                Network: _NetworkProvider.GetNetwork(c.PaymentId.CryptoCode)))
+                                                .Where(c => c.Network != null)
+                                                .Select(o =>
+                                                    (SupportedPaymentMethod: o.SupportedPaymentMethod,
+                                                    PaymentMethod: CreatePaymentMethodAsync(fetchingByCurrencyPair, o.Handler, o.SupportedPaymentMethod, o.Network, entity, store, logs)))
+                                                .ToList();
+            List<ISupportedPaymentMethod> supported = new List<ISupportedPaymentMethod>();
+            var paymentMethods = new PaymentMethodDictionary();
+            foreach (var o in supportedPaymentMethods)
+            {
+                var paymentMethod = await o.PaymentMethod;
+                if (paymentMethod == null)
+                    continue;
+                supported.Add(o.SupportedPaymentMethod);
+                paymentMethods.Add(paymentMethod);
+            }
+
+            if (supported.Count == 0)
+            {
+                StringBuilder errors = new StringBuilder();
+                errors.AppendLine("Warning: No wallet has been linked to your BTCPay Store. See the following link for more information on how to connect your store and wallet. (https://docs.btcpayserver.org/btcpay-basics/gettingstarted#connecting-btcpay-store-to-your-wallet)");
+                foreach (var error in logs.ToList())
+                {
+                    errors.AppendLine(error.ToString());
+                }
+                throw new BitpayHttpException(400, errors.ToString());
+            }
+
+            entity.SetSupportedPaymentMethods(supported);
+            entity.SetPaymentMethods(paymentMethods);
+            entity.PosData = invoice.PosData;
+
+            foreach (var app in await getAppsTaggingStore)
+            {
+                entity.InternalTags.Add(AppService.GetAppInternalTag(app.Id));
+            }
+
+            using (logs.Measure("Saving invoice"))
+            {
+                entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
+            }
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await fetchingAll;
+                }
+                catch (AggregateException ex)
+                {
+                    ex.Handle(e => { logs.Write($"Error while fetching rates {ex}"); return true; });
+                }
+                await _InvoiceRepository.AddInvoiceLogs(entity.Id, logs);
+            });
+            _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, InvoiceEvent.Created));
+            var resp = entity.EntityToDTO(_NetworkProvider);
+            return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
+        }
+
+        private Task WhenAllFetched(InvoiceLogs logs, Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair)
+        {
+            return Task.WhenAll(fetchingByCurrencyPair.Select(async pair =>
+            {
+                var rateResult = await pair.Value;
+                logs.Write($"{pair.Key}: The rating rule is {rateResult.Rule}");
+                logs.Write($"{pair.Key}: The evaluated rating rule is {rateResult.EvaluatedRule}");
+                if (rateResult.Errors.Count != 0)
+                {
+                    var allRateRuleErrors = string.Join(", ", rateResult.Errors.ToArray());
+                    logs.Write($"{pair.Key}: Rate rule error ({allRateRuleErrors})");
+                }
+                foreach (var ex in rateResult.ExchangeExceptions)
+                {
+                    logs.Write($"{pair.Key}: Exception reaching exchange {ex.ExchangeName} ({ex.Exception.Message})");
+                }
+            }).ToArray());
+        }
+
+        private async Task<PaymentMethod> CreatePaymentMethodAsync(Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreData store, InvoiceLogs logs)
+        {
+            try
+            {
+                var logPrefix = $"{supportedPaymentMethod.PaymentId.ToString(true)}:";
+                var storeBlob = store.GetStoreBlob();
+                var preparePayment = handler.PreparePayment(supportedPaymentMethod, store, network);
+                var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
+                if (rate.BidAsk == null)
+                {
+                    return null;
+                }
+                PaymentMethod paymentMethod = new PaymentMethod();
+                paymentMethod.ParentEntity = entity;
+                paymentMethod.Network = network;
+                paymentMethod.SetId(supportedPaymentMethod.PaymentId);
+                paymentMethod.Rate = rate.BidAsk.Bid;
+                paymentMethod.PreferOnion = this.Request.IsOnion();
+
+                using (logs.Measure($"{logPrefix} Payment method details creation"))
+                {
+                    var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network, preparePayment);
+                    paymentMethod.SetPaymentMethodDetails(paymentDetails);
+                }
+
+                Func<Money, Money, bool> compare = null;
+                CurrencyValue limitValue = null;
+                string errorMessage = null;
+                if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.LightningLike &&
+                   storeBlob.LightningMaxValue != null)
+                {
+                    compare = (a, b) => a > b;
+                    limitValue = storeBlob.LightningMaxValue;
+                    errorMessage = "The amount of the invoice is too high to be paid with lightning";
+                }
+                else if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.BTCLike &&
+                   storeBlob.OnChainMinValue != null)
+                {
+                    compare = (a, b) => a < b;
+                    limitValue = storeBlob.OnChainMinValue;
+                    errorMessage = "The amount of the invoice is too low to be paid on chain";
+                }
+
+                if (compare != null)
+                {
+                    var limitValueRate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, limitValue.Currency)];
+                    if (limitValueRate.BidAsk != null)
+                    {
+                        var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.BidAsk.Bid);
+                        if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
+                        {
+                            logs.Write($"{logPrefix} {errorMessage}");
+                            return null;
+                        }
+                    }
+                }
+                ///////////////
+
+
+#pragma warning disable CS0618
+                if (paymentMethod.GetId().IsBTCOnChain)
+                {
+                    entity.TxFee = paymentMethod.NextNetworkFee;
+                    entity.Rate = paymentMethod.Rate;
+                    entity.DepositAddress = paymentMethod.DepositAddress;
+                }
+#pragma warning restore CS0618
+                return paymentMethod;
+            }
+            catch (PaymentMethodUnavailableException ex)
+            {
+                logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: Payment method unavailable ({ex.Message})");
+            }
+            catch (Exception ex)
+            {
+                logs.Write($"{supportedPaymentMethod.PaymentId.CryptoCode}: Unexpected exception ({ex.ToString()})");
+            }
+            return null;
+        }
+
+        private SpeedPolicy ParseSpeedPolicy(string transactionSpeed, SpeedPolicy defaultPolicy)
+        {
+            if (transactionSpeed == null)
+                return defaultPolicy;
+            var mappings = new Dictionary<string, SpeedPolicy>();
+            mappings.Add("low", SpeedPolicy.LowSpeed);
+            mappings.Add("low-medium", SpeedPolicy.LowMediumSpeed);
+            mappings.Add("medium", SpeedPolicy.MediumSpeed);
+            mappings.Add("high", SpeedPolicy.HighSpeed);
+            if (!mappings.TryGetValue(transactionSpeed, out SpeedPolicy policy))
+                policy = defaultPolicy;
+            return policy;
+        }
+
+        private void FillBuyerInfo(Buyer buyer, BuyerInformation buyerInformation)
+        {
+            if (buyer == null)
+                return;
+            buyerInformation.BuyerAddress1 = buyerInformation.BuyerAddress1 ?? buyer.Address1;
+            buyerInformation.BuyerAddress2 = buyerInformation.BuyerAddress2 ?? buyer.Address2;
+            buyerInformation.BuyerCity = buyerInformation.BuyerCity ?? buyer.City;
+            buyerInformation.BuyerCountry = buyerInformation.BuyerCountry ?? buyer.country;
+            buyerInformation.BuyerEmail = buyerInformation.BuyerEmail ?? buyer.email;
+            buyerInformation.BuyerName = buyerInformation.BuyerName ?? buyer.Name;
+            buyerInformation.BuyerPhone = buyerInformation.BuyerPhone ?? buyer.phone;
+            buyerInformation.BuyerState = buyerInformation.BuyerState ?? buyer.State;
+            buyerInformation.BuyerZip = buyerInformation.BuyerZip ?? buyer.zip;
+        }
+
+        private TDest Map<TFrom, TDest>(TFrom data)
+        {
+            return JsonConvert.DeserializeObject<TDest>(JsonConvert.SerializeObject(data));
+        }
+    }
 }

BTCPayServer/Controllers/Macaroons.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Controllers
+{
+    public class Macaroons
+    {
+        public class Macaroon
+        {
+            public Macaroon(byte[] bytes)
+            {
+                Bytes = bytes;
+                Hex = NBitcoin.DataEncoders.Encoders.Hex.EncodeData(bytes);
+            }
+
+            public string Hex { get; set; }
+            public byte[] Bytes { get; set; }
+        }
+        public static async Task<Macaroons> GetFromDirectoryAsync(string directoryPath)
+        {
+            if (directoryPath == null)
+                throw new ArgumentNullException(nameof(directoryPath));
+            Macaroons macaroons = new Macaroons();
+            if (!Directory.Exists(directoryPath))
+                throw new DirectoryNotFoundException("Macaroons directory not found");
+            foreach(var file in Directory.GetFiles(directoryPath, "*.macaroon"))
+            {
+                try
+                {
+                    switch (Path.GetFileName(file))
+                    {
+                        case "admin.macaroon":
+                            macaroons.AdminMacaroon = new Macaroon(await File.ReadAllBytesAsync(file));
+                            break;
+                        case "readonly.macaroon":
+                            macaroons.ReadonlyMacaroon = new Macaroon(await File.ReadAllBytesAsync(file));
+                            break;
+                        case "invoice.macaroon":
+                            macaroons.InvoiceMacaroon = new Macaroon(await File.ReadAllBytesAsync(file));
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                catch { }
+            }
+            return macaroons;
+        }
+
+        public Macaroons Clone()
+        {
+            return new Macaroons()
+            {
+                AdminMacaroon = AdminMacaroon,
+                InvoiceMacaroon = InvoiceMacaroon,
+                ReadonlyMacaroon = ReadonlyMacaroon
+            };
+        }
+
+        public Macaroon ReadonlyMacaroon { get; set; }
+
+        public Macaroon InvoiceMacaroon { get; set; }
+        public Macaroon AdminMacaroon { get; set; }
+    }
+}

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,530 +8,349 @@ 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]
-	[Route("[controller]/[action]")]
-	public class ManageController : Controller
-	{
-		private readonly UserManager<ApplicationUser> _userManager;
-		private readonly SignInManager<ApplicationUser> _signInManager;
-		private readonly IEmailSender _emailSender;
-		private readonly ILogger _logger;
-		private readonly UrlEncoder _urlEncoder;
-		TokenRepository _TokenRepository;
-		private readonly BTCPayWallet _Wallet;
-		IHostingEnvironment _Env;
-		StoreRepository _StoreRepository;
-
-
-		private const string AuthenicatorUriFormat = "otpauth://totp/{0}:{1}?secret={2}&issuer={0}&digits=6";
-
-		public ManageController(
-		  UserManager<ApplicationUser> userManager,
-		  SignInManager<ApplicationUser> signInManager,
-		  IEmailSender emailSender,
-		  ILogger<ManageController> logger,
-		  UrlEncoder urlEncoder,
-		  TokenRepository tokenRepository,
-		  BTCPayWallet wallet,
-		  StoreRepository storeRepository,
-		  IHostingEnvironment env)
-		{
-			_userManager = userManager;
-			_signInManager = signInManager;
-			_emailSender = emailSender;
-			_logger = logger;
-			_urlEncoder = urlEncoder;
-			_TokenRepository = tokenRepository;
-			_Wallet = wallet;
-			_Env = env;
-			_StoreRepository = storeRepository;
-		}
-
-		[TempData]
-		public string StatusMessage
-		{
-			get; set;
-		}
-
-		[HttpGet]
-		public async Task<IActionResult> Index()
-		{
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-
-			var model = new IndexViewModel
-			{
-				Username = user.UserName,
-				Email = user.Email,
-				PhoneNumber = user.PhoneNumber,
-				IsEmailConfirmed = user.EmailConfirmed,
-				StatusMessage = StatusMessage
-			};
-			return View(model);
-		}
-
-		[HttpPost]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> Index(IndexViewModel model)
-		{
-			if(!ModelState.IsValid)
-			{
-				return View(model);
-			}
-
-			bool needUpdate = false;
-
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-			
-			var email = user.Email;
-			if(model.Email != email)
-			{
-				var setEmailResult = await _userManager.SetEmailAsync(user, model.Email);
-				if(!setEmailResult.Succeeded)
-				{
-					throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'.");
-				}
-			}
-
-			var phoneNumber = user.PhoneNumber;
-			if(model.PhoneNumber != phoneNumber)
-			{
-				var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, model.PhoneNumber);
-				if(!setPhoneResult.Succeeded)
-				{
-					throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'.");
-				}
-			}
-
-			if(needUpdate)
-			{
-				var result = await _userManager.UpdateAsync(user);
-				if(!result.Succeeded)
-				{
-					throw new ApplicationException($"Unexpected error occurred updating user with ID '{user.Id}'.");
-				}
-			}
-
-			StatusMessage = "Your profile has been updated";
-			return RedirectToAction(nameof(Index));
-		}
-
-		[HttpPost]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> SendVerificationEmail(IndexViewModel 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)}'.");
-			}
-
-			var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
-			var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
-			var email = user.Email;
-			await _emailSender.SendEmailConfirmationAsync(email, callbackUrl);
-
-			StatusMessage = "Verification email sent. Please check your email.";
-			return RedirectToAction(nameof(Index));
-		}
-
-		[HttpGet]
-		public async Task<IActionResult> ChangePassword()
-		{
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-
-			var hasPassword = await _userManager.HasPasswordAsync(user);
-			if(!hasPassword)
-			{
-				return RedirectToAction(nameof(SetPassword));
-			}
-
-			var model = new ChangePasswordViewModel { StatusMessage = StatusMessage };
-			return View(model);
-		}
-
-		[HttpPost]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> ChangePassword(ChangePasswordViewModel 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)}'.");
-			}
-
-			var changePasswordResult = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
-			if(!changePasswordResult.Succeeded)
-			{
-				AddErrors(changePasswordResult);
-				return View(model);
-			}
-
-			await _signInManager.SignInAsync(user, isPersistent: false);
-			_logger.LogInformation("User changed their password successfully.");
-			StatusMessage = "Your password has been changed.";
-
-			return RedirectToAction(nameof(ChangePassword));
-		}
-
-		[HttpGet]
-		public async Task<IActionResult> SetPassword()
-		{
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-
-			var hasPassword = await _userManager.HasPasswordAsync(user);
-
-			if(hasPassword)
-			{
-				return RedirectToAction(nameof(ChangePassword));
-			}
-
-			var model = new SetPasswordViewModel { StatusMessage = StatusMessage };
-			return View(model);
-		}
-
-		[HttpPost]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> SetPassword(SetPasswordViewModel 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)}'.");
-			}
-
-			var addPasswordResult = await _userManager.AddPasswordAsync(user, model.NewPassword);
-			if(!addPasswordResult.Succeeded)
-			{
-				AddErrors(addPasswordResult);
-				return View(model);
-			}
-
-			await _signInManager.SignInAsync(user, isPersistent: false);
-			StatusMessage = "Your password has been set.";
-
-			return RedirectToAction(nameof(SetPassword));
-		}
-
-		[HttpGet]
-		public async Task<IActionResult> ExternalLogins()
-		{
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-
-			var model = new ExternalLoginsViewModel { CurrentLogins = await _userManager.GetLoginsAsync(user) };
-			model.OtherLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
-				.Where(auth => model.CurrentLogins.All(ul => auth.Name != ul.LoginProvider))
-				.ToList();
-			model.ShowRemoveButton = await _userManager.HasPasswordAsync(user) || model.CurrentLogins.Count > 1;
-			model.StatusMessage = StatusMessage;
-
-			return View(model);
-		}
-
-		[HttpPost]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> LinkLogin(string provider)
-		{
-			// Clear the existing external cookie to ensure a clean login process
-			await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
-
-			// Request a redirect to the external login provider to link a login for the current user
-			var redirectUrl = Url.Action(nameof(LinkLoginCallback));
-			var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl, _userManager.GetUserId(User));
-			return new ChallengeResult(provider, properties);
-		}
-
-		[HttpGet]
-		public async Task<IActionResult> LinkLoginCallback()
-		{
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-
-			var info = await _signInManager.GetExternalLoginInfoAsync(user.Id);
-			if(info == null)
-			{
-				throw new ApplicationException($"Unexpected error occurred loading external login info for user with ID '{user.Id}'.");
-			}
-
-			var result = await _userManager.AddLoginAsync(user, info);
-			if(!result.Succeeded)
-			{
-				throw new ApplicationException($"Unexpected error occurred adding external login for user with ID '{user.Id}'.");
-			}
-
-			// Clear the existing external cookie to ensure a clean login process
-			await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
-
-			StatusMessage = "The external login was added.";
-			return RedirectToAction(nameof(ExternalLogins));
-		}
-
-		[HttpPost]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> RemoveLogin(RemoveLoginViewModel model)
-		{
-			var user = await _userManager.GetUserAsync(User);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
-
-			var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
-			if(!result.Succeeded)
-			{
-				throw new ApplicationException($"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
-			}
-
-			await _signInManager.SignInAsync(user, isPersistent: false);
-			StatusMessage = "The external login was removed.";
-			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 occured 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 occured 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).Replace("-", string.Empty);
-
-			var is2faTokenValid = await _userManager.VerifyTwoFactorTokenAsync(
-				user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
-
-			if(!is2faTokenValid)
-			{
-				ModelState.AddModelError("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
-
-		private void AddErrors(IdentityResult result)
-		{
-			foreach(var error in result.Errors)
-			{
-				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(
-				AuthenicatorUriFormat,
-				_urlEncoder.Encode("BTCPayServer"),
-				_urlEncoder.Encode(email),
-				unformattedKey);
-		}
-
-		#endregion
-	}
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [Route("[controller]/[action]")]
+    public partial class ManageController : Controller
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+        private readonly EmailSenderFactory _EmailSenderFactory;
+        private readonly ILogger _logger;
+        private readonly UrlEncoder _urlEncoder;
+        TokenRepository _TokenRepository;
+        IHostingEnvironment _Env;
+        private readonly U2FService _u2FService;
+        private readonly BTCPayServerEnvironment _btcPayServerEnvironment;
+        StoreRepository _StoreRepository;
+
+
+
+        public ManageController(
+          UserManager<ApplicationUser> userManager,
+          SignInManager<ApplicationUser> signInManager,
+          EmailSenderFactory emailSenderFactory,
+          ILogger<ManageController> logger,
+          UrlEncoder urlEncoder,
+          TokenRepository tokenRepository,
+          BTCPayWalletProvider walletProvider,
+          StoreRepository storeRepository,
+          IHostingEnvironment env, 
+          U2FService  u2FService,
+          BTCPayServerEnvironment btcPayServerEnvironment)
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+            _EmailSenderFactory = emailSenderFactory;
+            _logger = logger;
+            _urlEncoder = urlEncoder;
+            _TokenRepository = tokenRepository;
+            _Env = env;
+            _u2FService = u2FService;
+            _btcPayServerEnvironment = btcPayServerEnvironment;
+            _StoreRepository = storeRepository;
+        }
+
+        [TempData]
+        public string StatusMessage
+        {
+            get; set;
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> Index()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var model = new IndexViewModel
+            {
+                Username = user.UserName,
+                Email = user.Email,
+                PhoneNumber = user.PhoneNumber,
+                IsEmailConfirmed = user.EmailConfirmed,
+                StatusMessage = StatusMessage
+            };
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Index(IndexViewModel model)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+
+            bool needUpdate = false;
+
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var email = user.Email;
+            if (model.Email != email)
+            {
+                var setEmailResult = await _userManager.SetEmailAsync(user, model.Email);
+                if (!setEmailResult.Succeeded)
+                {
+                    throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'.");
+                }
+                await _userManager.SetUserNameAsync(user, model.Username);
+            }
+
+            var phoneNumber = user.PhoneNumber;
+            if (model.PhoneNumber != phoneNumber)
+            {
+                var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, model.PhoneNumber);
+                if (!setPhoneResult.Succeeded)
+                {
+                    throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'.");
+                }
+            }
+
+            if (needUpdate)
+            {
+                var result = await _userManager.UpdateAsync(user);
+                if (!result.Succeeded)
+                {
+                    throw new ApplicationException($"Unexpected error occurred updating user with ID '{user.Id}'.");
+                }
+            }
+
+            StatusMessage = "Your profile has been updated";
+            return RedirectToAction(nameof(Index));
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> SendVerificationEmail(IndexViewModel 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)}'.");
+            }
+
+            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
+            var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
+            var email = user.Email;
+            _EmailSenderFactory.GetEmailSender().SendEmailConfirmation(email, callbackUrl);
+            StatusMessage = "Verification email sent. Please check your email.";
+            return RedirectToAction(nameof(Index));
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> ChangePassword()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var hasPassword = await _userManager.HasPasswordAsync(user);
+            if (!hasPassword)
+            {
+                return RedirectToAction(nameof(SetPassword));
+            }
+
+            var model = new ChangePasswordViewModel { StatusMessage = StatusMessage };
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> ChangePassword(ChangePasswordViewModel 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)}'.");
+            }
+
+            var changePasswordResult = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
+            if (!changePasswordResult.Succeeded)
+            {
+                AddErrors(changePasswordResult);
+                return View(model);
+            }
+
+            await _signInManager.SignInAsync(user, isPersistent: false);
+            _logger.LogInformation("User changed their password successfully.");
+            StatusMessage = "Your password has been changed.";
+
+            return RedirectToAction(nameof(ChangePassword));
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> SetPassword()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var hasPassword = await _userManager.HasPasswordAsync(user);
+
+            if (hasPassword)
+            {
+                return RedirectToAction(nameof(ChangePassword));
+            }
+
+            var model = new SetPasswordViewModel { StatusMessage = StatusMessage };
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> SetPassword(SetPasswordViewModel 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)}'.");
+            }
+
+            var addPasswordResult = await _userManager.AddPasswordAsync(user, model.NewPassword);
+            if (!addPasswordResult.Succeeded)
+            {
+                AddErrors(addPasswordResult);
+                return View(model);
+            }
+
+            await _signInManager.SignInAsync(user, isPersistent: false);
+            StatusMessage = "Your password has been set.";
+
+            return RedirectToAction(nameof(SetPassword));
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> ExternalLogins()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var model = new ExternalLoginsViewModel { CurrentLogins = await _userManager.GetLoginsAsync(user) };
+            model.OtherLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
+                .Where(auth => model.CurrentLogins.All(ul => auth.Name != ul.LoginProvider))
+                .ToList();
+            model.ShowRemoveButton = await _userManager.HasPasswordAsync(user) || model.CurrentLogins.Count > 1;
+            model.StatusMessage = StatusMessage;
+
+            return View(model);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> LinkLogin(string provider)
+        {
+            // Clear the existing external cookie to ensure a clean login process
+            await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
+
+            // Request a redirect to the external login provider to link a login for the current user
+            var redirectUrl = Url.Action(nameof(LinkLoginCallback));
+            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl, _userManager.GetUserId(User));
+            return new ChallengeResult(provider, properties);
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> LinkLoginCallback()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var info = await _signInManager.GetExternalLoginInfoAsync(user.Id);
+            if (info == null)
+            {
+                throw new ApplicationException($"Unexpected error occurred loading external login info for user with ID '{user.Id}'.");
+            }
+
+            var result = await _userManager.AddLoginAsync(user, info);
+            if (!result.Succeeded)
+            {
+                throw new ApplicationException($"Unexpected error occurred adding external login for user with ID '{user.Id}'.");
+            }
+
+            // Clear the existing external cookie to ensure a clean login process
+            await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
+
+            StatusMessage = "The external login was added.";
+            return RedirectToAction(nameof(ExternalLogins));
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> RemoveLogin(RemoveLoginViewModel model)
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
+
+            var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
+            if (!result.Succeeded)
+            {
+                throw new ApplicationException($"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
+            }
+
+            await _signInManager.SignInAsync(user, isPersistent: false);
+            StatusMessage = "The external login was removed.";
+            return RedirectToAction(nameof(ExternalLogins));
+        }
+
+
+        #region Helpers
+
+        private void AddErrors(IdentityResult result)
+        {
+            foreach (var error in result.Errors)
+            {
+                ModelState.AddModelError(string.Empty, error.Description);
+            }
+        }
+        #endregion
+    }
 }

BTCPayServer/Controllers/PaymentRequestActionResult.cs

@@ -1,40 +0,0 @@
-using Microsoft.AspNetCore.Mvc;
-using NBitcoin.Payment;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Controllers
-{
-	public class PaymentRequestActionResult : IActionResult
-	{
-		PaymentRequest req;
-		public PaymentRequestActionResult(PaymentRequest req)
-		{
-			this.req = req;
-		}
-		public Task ExecuteResultAsync(ActionContext context)
-		{
-			context.HttpContext.Response.Headers["Content-Transfer-Encoding"] = "binary";
-			context.HttpContext.Response.ContentType = "application/bitcoin-paymentrequest";
-			req.WriteTo(context.HttpContext.Response.Body);
-			return Task.CompletedTask;
-		}
-	}
-	public class PaymentAckActionResult : IActionResult
-	{
-		PaymentACK req;
-		public PaymentAckActionResult(PaymentACK req)
-		{
-			this.req = req;
-		}
-		public Task ExecuteResultAsync(ActionContext context)
-		{
-			context.HttpContext.Response.Headers["Content-Transfer-Encoding"] = "binary";
-			context.HttpContext.Response.ContentType = "application/bitcoin-paymentack";
-			req.WriteTo(context.HttpContext.Response.Body);
-			return Task.CompletedTask;
-		}
-	}
-}

BTCPayServer/Controllers/PaymentRequestController.cs

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

BTCPayServer/Controllers/PublicController.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Filters;
+using BTCPayServer.Models;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Services.Stores;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Controllers
+{
+    public class PublicController : Controller
+    {
+        public PublicController(InvoiceController invoiceController,
+            StoreRepository storeRepository)
+        {
+            _InvoiceController = invoiceController;
+            _StoreRepository = storeRepository;
+        }
+
+        private InvoiceController _InvoiceController;
+        private StoreRepository _StoreRepository;
+
+        [HttpPost]
+        [Route("api/v1/invoices")]
+        [MediaTypeAcceptConstraintAttribute("text/html")]
+        [IgnoreAntiforgeryToken]
+        [EnableCors(CorsPolicies.All)]
+        public async Task<IActionResult> PayButtonHandle([FromForm]PayButtonViewModel model, CancellationToken cancellationToken)
+        {
+            var store = await _StoreRepository.FindStore(model.StoreId);
+            if (store == null)
+                ModelState.AddModelError("Store", "Invalid store");
+            else
+            {
+                var storeBlob = store.GetStoreBlob();
+                if (!storeBlob.AnyoneCanInvoice)
+                    ModelState.AddModelError("Store", "Store has not enabled Pay Button");
+            }
+            
+            if (model == null || model.Price <= 0)
+                ModelState.AddModelError("Price", "Price must be greater than 0");
+
+            if (!ModelState.IsValid)
+                return View();
+
+            var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
+            {
+                Price = model.Price,
+                Currency = model.Currency,
+                ItemDesc = model.CheckoutDesc,
+                OrderId = model.OrderId,
+                NotificationEmail = model.NotifyEmail,
+                NotificationURL = model.ServerIpn,
+                RedirectURL = model.BrowserRedirect,
+                FullNotifications = true
+            }, store, HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
+            return Redirect(invoice.Data.Url);
+        }
+    }
+}

BTCPayServer/Controllers/PublicLightningNodeInfoController.cs

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

BTCPayServer/Controllers/RateController.cs

@@ -7,34 +7,227 @@ using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Rating;
+using Newtonsoft.Json;
+using Microsoft.AspNetCore.Authorization;
+using BTCPayServer.Authentication;
+using Microsoft.AspNetCore.Cors;
+using System.Threading;
 
 namespace BTCPayServer.Controllers
 {
-	public class RateController : Controller
-	{
-		IRateProvider _RateProvider;
-		CurrencyNameTable _CurrencyNameTable;
-		public RateController(IRateProvider rateProvider, CurrencyNameTable currencyNameTable)
-		{
-			_RateProvider = rateProvider ?? throw new ArgumentNullException(nameof(rateProvider));
-			_CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
-		}
+    [Authorize(AuthenticationSchemes = Security.Policies.BitpayAuthentication)]
+    [AllowAnonymous]
+    [EnableCors(CorsPolicies.All)]
+    public class RateController : Controller
+    {
+        RateFetcher _RateProviderFactory;
+        BTCPayNetworkProvider _NetworkProvider;
+        CurrencyNameTable _CurrencyNameTable;
+        StoreRepository _StoreRepo;
 
-		[Route("rates")]
-		[HttpGet]
-		[BitpayAPIConstraint]
-		public async Task<DataWrapper<NBitpayClient.Rate[]>> GetRates()
-		{
-			var allRates = (await _RateProvider.GetRatesAsync());
-			return new DataWrapper<NBitpayClient.Rate[]>
-					(allRates.Select(r =>
-							new NBitpayClient.Rate()
-							{
-								Code = r.Currency,
-								Name = _CurrencyNameTable.GetCurrencyData(r.Currency)?.Name,
-								Value = r.Value
-							}).Where(n => n.Name != null).ToArray());
+        public TokenRepository TokenRepository { get; }
 
-		}
-	}
+        public RateController(
+            RateFetcher rateProviderFactory,
+            BTCPayNetworkProvider networkProvider,
+            TokenRepository tokenRepository,
+            StoreRepository storeRepo,
+            CurrencyNameTable currencyNameTable)
+        {
+            _RateProviderFactory = rateProviderFactory ?? throw new ArgumentNullException(nameof(rateProviderFactory));
+            _NetworkProvider = networkProvider;
+            TokenRepository = tokenRepository;
+            _StoreRepo = storeRepo;
+            _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
+        }
+
+        [Route("rates/{baseCurrency}")]
+        [HttpGet]
+        [BitpayAPIConstraint]
+        public async Task<IActionResult> GetBaseCurrencyRates(string baseCurrency, string storeId, CancellationToken cancellationToken)
+        {
+            storeId = await GetStoreId(storeId);
+            var store = this.HttpContext.GetStoreData();
+            if (store == null || store.Id != storeId)
+                store = await _StoreRepo.FindStore(storeId);
+            if (store == null)
+            {
+                var err = Json(new BitpayErrorsModel() { Error = "Store not found" });
+                err.StatusCode = 404;
+                return err;
+            }
+            var supportedMethods = store.GetSupportedPaymentMethods(_NetworkProvider);
+
+            var currencyCodes = supportedMethods.Where(method => !string.IsNullOrEmpty(method.PaymentId.CryptoCode))
+                .Select(method => method.PaymentId.CryptoCode).Distinct();
+
+            var currencypairs = BuildCurrencyPairs(currencyCodes, baseCurrency);
+            
+            var result = await GetRates2(currencypairs, store.Id, cancellationToken);
+            var rates = (result as JsonResult)?.Value as Rate[];
+            if (rates == null)
+                return result;
+            return Json(new DataWrapper<Rate[]>(rates));
+        }
+
+
+        [Route("rates/{baseCurrency}/{currency}")]
+        [HttpGet]
+        [BitpayAPIConstraint]
+        public async Task<IActionResult> GetCurrencyPairRate(string baseCurrency, string currency, string storeId, CancellationToken cancellationToken)
+        {
+            storeId = await GetStoreId(storeId);
+            var result = await GetRates2($"{baseCurrency}_{currency}", storeId, cancellationToken);
+            var rates = (result as JsonResult)?.Value as Rate[];
+            if (rates == null)
+                return result;
+            return Json(new DataWrapper<Rate>(rates.First()));
+        }
+
+        [Route("rates")]
+        [HttpGet]
+        [BitpayAPIConstraint]
+        public async Task<IActionResult> GetRates(string currencyPairs, string storeId, CancellationToken cancellationToken)
+        {
+            var result = await GetRates2(currencyPairs, storeId, cancellationToken);
+            var rates = (result as JsonResult)?.Value as Rate[];
+            if (rates == null)
+                return result;
+            return Json(new DataWrapper<Rate[]>(rates));
+        }
+
+        private async Task<string> GetStoreId(string storeId)
+        {
+            if (storeId != null && this.HttpContext.GetStoreData()?.Id == storeId)
+                return storeId;
+            if(storeId == null)
+            {
+                var tokens = await this.TokenRepository.GetTokens(this.User.GetSIN());
+                storeId = tokens.Select(s => s.StoreId).Where(s => s != null).FirstOrDefault();
+            }
+            if (storeId == null)
+                return null;
+            var store = await _StoreRepo.FindStore(storeId);
+            if (store == null)
+                return null;
+            this.HttpContext.SetStoreData(store);
+            return storeId;
+        }
+
+        [Route("api/rates")]
+        [HttpGet]
+        public async Task<IActionResult> GetRates2(string currencyPairs, string storeId, CancellationToken cancellationToken)
+        {
+            storeId = await GetStoreId(storeId);
+            if (storeId == null)
+            {
+                var result = Json(new BitpayErrorsModel() { Error = "You need to specify storeId (in your store settings)" });
+                result.StatusCode = 400;
+                return result;
+            }
+            var store = this.HttpContext.GetStoreData();
+            if (store == null || store.Id != storeId)
+                store = await _StoreRepo.FindStore(storeId);
+            if (store == null)
+            {
+                var result = Json(new BitpayErrorsModel() { Error = "Store not found" });
+                result.StatusCode = 404;
+                return result;
+            }
+
+            if (currencyPairs == null)
+            {
+                currencyPairs = store.GetStoreBlob().GetDefaultCurrencyPairString();
+                if (string.IsNullOrEmpty(currencyPairs))
+                {
+                    var result = Json(new BitpayErrorsModel() { Error = "You need to setup the default currency pairs in 'Store Settings / Rates' or specify 'currencyPairs' query parameter (eg. BTC_USD,LTC_CAD)." });
+                    result.StatusCode = 400;
+                    return result;
+                }
+            }
+
+
+            var rules = store.GetStoreBlob().GetRateRules(_NetworkProvider);
+
+            HashSet<CurrencyPair> pairs = new HashSet<CurrencyPair>();
+            foreach (var currency in currencyPairs.Split(','))
+            {
+                if (!CurrencyPair.TryParse(currency, out var pair))
+                {
+                    var result = Json(new BitpayErrorsModel() { Error = $"Currency pair {currency} uncorrectly formatted" });
+                    result.StatusCode = 400;
+                    return result;
+                }
+                pairs.Add(pair);
+            }
+
+            var fetching = _RateProviderFactory.FetchRates(pairs, rules, cancellationToken);
+            await Task.WhenAll(fetching.Select(f => f.Value).ToArray());
+            return Json(pairs
+                            .Select(r => (Pair: r, Value: fetching[r].GetAwaiter().GetResult().BidAsk?.Bid))
+                            .Where(r => r.Value.HasValue)
+                            .Select(r =>
+                            new Rate()
+                            {
+                                CryptoCode = r.Pair.Left,
+                                Code = r.Pair.Right,
+                                CurrencyPair = r.Pair.ToString(),
+                                Name = _CurrencyNameTable.GetCurrencyData(r.Pair.Right, true).Name,
+                                Value = r.Value.Value
+                            }).Where(n => n.Name != null).ToArray());
+        }
+
+        private static string BuildCurrencyPairs(IEnumerable<string> currencyCodes, string baseCrypto)
+        {
+            StringBuilder currencyPairsBuilder = new StringBuilder();
+            bool first = true;
+            foreach (var currencyCode in currencyCodes)
+            {
+                if(!first)
+                    currencyPairsBuilder.Append(",");
+                first = false;
+                currencyPairsBuilder.Append($"{baseCrypto}_{currencyCode}");
+            }
+            return currencyPairsBuilder.ToString();
+        }
+
+        public class Rate
+        {
+
+            [JsonProperty(PropertyName = "name")]
+            public string Name
+            {
+                get;
+                set;
+            }
+            [JsonProperty(PropertyName = "cryptoCode")]
+            public string CryptoCode
+            {
+                get;
+                set;
+            }
+
+            [JsonProperty(PropertyName = "currencyPair")]
+            public string CurrencyPair
+            {
+                get;
+                set;
+            }
+
+            [JsonProperty(PropertyName = "code")]
+            public string Code
+            {
+                get;
+                set;
+            }
+            [JsonProperty(PropertyName = "rate")]
+            public decimal Value
+            {
+                get;
+                set;
+            }
+        }
+    }
 }

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

@@ -1,97 +1,905 @@
-using BTCPayServer.Models;
+using BTCPayServer.Configuration;
+using Microsoft.Extensions.Logging;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Models;
 using BTCPayServer.Models.ServerViewModels;
+using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Mails;
-using BTCPayServer.Validations;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Validation;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
+using NBitcoin;
+using NBitcoin.DataEncoders;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.IO;
 using System.Linq;
 using System.Net;
+using System.Net.Http;
 using System.Net.Mail;
 using System.Threading.Tasks;
+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;
 
 namespace BTCPayServer.Controllers
 {
-	[Authorize(Roles = Roles.ServerAdmin)]
-	public class ServerController : Controller
-	{
-		private UserManager<ApplicationUser> _UserManager;
-		SettingsRepository _SettingsRepository;
+    [Authorize(Policy = BTCPayServer.Security.Policies.CanModifyServerSettings.Key)]
+    public partial class ServerController : Controller
+    {
+        private UserManager<ApplicationUser> _UserManager;
+        SettingsRepository _SettingsRepository;
+        private readonly NBXplorerDashboard _dashBoard;
+        private RateFetcher _RateProviderFactory;
+        private StoreRepository _StoreRepository;
+        LightningConfigurationProvider _LnConfigProvider;
+        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, SettingsRepository settingsRepository)
-		{
-			_UserManager = userManager;
-			_SettingsRepository = settingsRepository;
-		}
+        public ServerController(UserManager<ApplicationUser> userManager,
+            StoredFileRepository storedFileRepository,
+            FileService fileService,
+            IEnumerable<IStorageProviderService> storageProviderServices,
+            BTCPayServerOptions options,
+            RateFetcher rateProviderFactory,
+            SettingsRepository settingsRepository,
+            NBXplorerDashboard dashBoard,
+            IHttpClientFactory httpClientFactory,
+            LightningConfigurationProvider lnConfigProvider,
+            TorServices torServices,
+            StoreRepository storeRepository,
+            ApplicationDbContextFactory contextFactory)
+        {
+            _Options = options;
+            _StoredFileRepository = storedFileRepository;
+            _FileService = fileService;
+            _StorageProviderServices = storageProviderServices;
+            _UserManager = userManager;
+            _SettingsRepository = settingsRepository;
+            _dashBoard = dashBoard;
+            HttpClientFactory = httpClientFactory;
+            _RateProviderFactory = rateProviderFactory;
+            _StoreRepository = storeRepository;
+            _LnConfigProvider = lnConfigProvider;
+            _torServices = torServices;
+            _ContextFactory = contextFactory;
+        }
 
-		[Route("server/users")]
-		public IActionResult ListUsers()
-		{
-			var users = new UsersViewModel();
-			users.Users
-				= _UserManager.Users.Select(u => new UsersViewModel.UserViewModel()
-				{
-					Name = u.UserName,
-					Email = u.Email
-				}).ToList();
-			return View(users);
-		}
+        [Route("server/rates")]
+        public async Task<IActionResult> Rates()
+        {
+            var rates = (await _SettingsRepository.GetSettingAsync<RatesSetting>()) ?? new RatesSetting();
 
-		[Route("server/emails")]
-		public async Task<IActionResult> Emails()
-		{
-			var data = (await _SettingsRepository.GetSettingAsync<EmailSettings>()) ?? new EmailSettings();
-			return View(new EmailsViewModel() { Settings = data });
-		}
+            var vm = new RatesViewModel()
+            {
+                CacheMinutes = rates.CacheInMinutes,
+                PrivateKey = rates.PrivateKey,
+                PublicKey = rates.PublicKey
+            };
+            await FetchRateLimits(vm);
+            return View(vm);
+        }
 
-		[Route("server/policies")]
-		public async Task<IActionResult> Policies()
-		{
-			var data = (await _SettingsRepository.GetSettingAsync<PoliciesSettings>()) ?? new PoliciesSettings();
-			return View(data);
-		}
-		[Route("server/policies")]
-		[HttpPost]
-		public async Task<IActionResult> Policies(PoliciesSettings settings)
-		{
-			await _SettingsRepository.UpdateSetting(settings);
-			TempData["StatusMessage"] = "Policies upadated successfully";
-			return View(settings);
-		}
+        private static async Task FetchRateLimits(RatesViewModel vm)
+        {
+            var coinAverage = GetCoinaverageService(vm, false);
+            if (coinAverage != null)
+            {
+                try
+                {
+                    vm.RateLimits = await coinAverage.GetRateLimitsAsync();
+                }
+                catch { }
+            }
+        }
 
-		[Route("server/emails")]
-		[HttpPost]
-		public async Task<IActionResult> Emails(EmailsViewModel model, string command)
-		{
-			if(command == "Test")
-			{
-				if(!ModelState.IsValid)
-					return View(model);
-				try
-				{
-					var client = model.Settings.CreateSmtpClient();
-					await client.SendMailAsync(model.Settings.From, model.TestEmail, "BTCPay test", "BTCPay test");
-					model.StatusMessage = "Email sent to " + model.TestEmail + ", please, verify you received it";
-				}
-				catch(Exception ex)
-				{
-					model.StatusMessage = "Error: " + ex.Message;
-				}
-				return View(model);
-			}
-			else
-			{
-				ModelState.Remove(nameof(model.TestEmail));
-				if(!ModelState.IsValid)
-					return View(model);
-				await _SettingsRepository.UpdateSetting(model.Settings);
-				model.StatusMessage = "Email settings saved";
-				return View(model);
-			}
-		}
-	}
+        [Route("server/rates")]
+        [HttpPost]
+        public async Task<IActionResult> Rates(RatesViewModel vm)
+        {
+            var rates = (await _SettingsRepository.GetSettingAsync<RatesSetting>()) ?? new RatesSetting();
+            rates.PrivateKey = vm.PrivateKey;
+            rates.PublicKey = vm.PublicKey;
+            rates.CacheInMinutes = vm.CacheMinutes;
+            try
+            {
+                var service = GetCoinaverageService(vm, true);
+                if (service != null)
+                    await service.TestAuthAsync();
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(vm.PrivateKey), "Invalid API key pair");
+            }
+            if (!ModelState.IsValid)
+            {
+                await FetchRateLimits(vm);
+                return View(vm);
+            }
+            await _SettingsRepository.UpdateSetting(rates);
+            StatusMessage = "Rate settings successfully updated";
+            return RedirectToAction(nameof(Rates));
+        }
+
+        private static CoinAverageRateProvider GetCoinaverageService(RatesViewModel vm, bool withAuth)
+        {
+            var settings = new CoinAverageSettings()
+            {
+                KeyPair = (vm.PublicKey, vm.PrivateKey)
+            };
+            if (!withAuth || settings.GetCoinAverageSignature() != null)
+            {
+                return new CoinAverageRateProvider()
+                { Authenticator = settings };
+            }
+            return null;
+        }
+
+        [Route("server/users")]
+        public IActionResult ListUsers()
+        {
+            var users = new UsersViewModel();
+            users.StatusMessage = StatusMessage;
+            users.Users
+                = _UserManager.Users.Select(u => new UsersViewModel.UserViewModel()
+                {
+                    Name = u.UserName,
+                    Email = u.Email,
+                    Id = u.Id
+                }).ToList();
+            return View(users);
+        }
+
+        [Route("server/users/{userId}")]
+        public new async Task<IActionResult> User(string userId)
+        {
+            var user = await _UserManager.FindByIdAsync(userId);
+            if (user == null)
+                return NotFound();
+            var roles = await _UserManager.GetRolesAsync(user);
+            var userVM = new UserViewModel();
+            userVM.Id = user.Id;
+            userVM.Email = user.Email;
+            userVM.IsAdmin = IsAdmin(roles);
+            return View(userVM);
+        }
+
+        [Route("server/maintenance")]
+        public IActionResult Maintenance()
+        {
+            MaintenanceViewModel vm = new MaintenanceViewModel();
+            vm.UserName = "btcpayserver";
+            vm.DNSDomain = this.Request.Host.Host;
+            vm.SetConfiguredSSH(_Options.SSHSettings);
+            if (IPAddress.TryParse(vm.DNSDomain, out var unused))
+                vm.DNSDomain = null;
+            return View(vm);
+        }
+
+        [Route("server/maintenance")]
+        [HttpPost]
+        public async Task<IActionResult> Maintenance(MaintenanceViewModel vm, string command)
+        {
+            if (!ModelState.IsValid)
+                return View(vm);
+            vm.SetConfiguredSSH(_Options.SSHSettings);
+            if (command == "changedomain")
+            {
+                if (string.IsNullOrWhiteSpace(vm.DNSDomain))
+                {
+                    ModelState.AddModelError(nameof(vm.DNSDomain), $"Required field");
+                    return View(vm);
+                }
+                vm.DNSDomain = vm.DNSDomain.Trim().ToLowerInvariant();
+                if (vm.DNSDomain.Equals(this.Request.Host.Host, StringComparison.OrdinalIgnoreCase))
+                    return View(vm);
+                if (IPAddress.TryParse(vm.DNSDomain, out var unused))
+                {
+                    ModelState.AddModelError(nameof(vm.DNSDomain), $"This should be a domain name");
+                    return View(vm);
+                }
+                if (vm.DNSDomain.Equals(this.Request.Host.Host, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    ModelState.AddModelError(nameof(vm.DNSDomain), $"The server is already set to use this domain");
+                    return View(vm);
+                }
+                var builder = new UriBuilder();
+                using (var client = new HttpClient(new HttpClientHandler()
+                {
+                    ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
+                }))
+                {
+                    try
+                    {
+                        builder.Scheme = this.Request.Scheme;
+                        builder.Host = vm.DNSDomain;
+                        var addresses1 = GetAddressAsync(this.Request.Host.Host);
+                        var addresses2 = GetAddressAsync(vm.DNSDomain);
+                        await Task.WhenAll(addresses1, addresses2);
+
+                        var addressesSet = addresses1.GetAwaiter().GetResult().Select(c => c.ToString()).ToHashSet();
+                        var hasCommonAddress = addresses2.GetAwaiter().GetResult().Select(c => c.ToString()).Any(s => addressesSet.Contains(s));
+                        if (!hasCommonAddress)
+                        {
+                            ModelState.AddModelError(nameof(vm.DNSDomain), $"Invalid host ({vm.DNSDomain} is not pointing to this BTCPay instance)");
+                            return View(vm);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        var messages = new List<object>();
+                        messages.Add(ex.Message);
+                        if (ex.InnerException != null)
+                            messages.Add(ex.InnerException.Message);
+                        ModelState.AddModelError(nameof(vm.DNSDomain), $"Invalid domain ({string.Join(", ", messages.ToArray())})");
+                        return View(vm);
+                    }
+                }
+
+                var error = RunSSH(vm, $"changedomain.sh {vm.DNSDomain}");
+                if (error != null)
+                    return error;
+
+                builder.Path = null;
+                builder.Query = null;
+                StatusMessage = $"Domain name changing... the server will restart, please use \"{builder.Uri.AbsoluteUri}\"";
+            }
+            else if (command == "update")
+            {
+                var error = RunSSH(vm, $"btcpay-update.sh");
+                if (error != null)
+                    return error;
+                StatusMessage = $"The server might restart soon if an update is available...";
+            }
+            else if (command == "clean")
+            {
+                var error = RunSSH(vm, $"btcpay-clean.sh");
+                if (error != null)
+                    return error;
+                StatusMessage = $"The old docker images will be cleaned soon...";
+            }
+            else
+            {
+                return NotFound();
+            }
+            return RedirectToAction(nameof(Maintenance));
+        }
+
+        private Task<IPAddress[]> GetAddressAsync(string domainOrIP)
+        {
+            if (IPAddress.TryParse(domainOrIP, out var ip))
+                return Task.FromResult(new[] { ip });
+            return Dns.GetHostAddressesAsync(domainOrIP);
+        }
+
+        public static string RunId = Encoders.Hex.EncodeData(NBitcoin.RandomUtils.GetBytes(32));
+        [HttpGet]
+        [Route("runid")]
+        [AllowAnonymous]
+        public IActionResult SeeRunId(string expected = null)
+        {
+            if (expected == RunId)
+                return Ok();
+            return BadRequest();
+        }
+
+        private IActionResult RunSSH(MaintenanceViewModel vm, string ssh)
+        {
+            ssh = $"sudo bash -c '. /etc/profile.d/btcpay-env.sh && nohup {ssh} > /dev/null 2>&1 & disown'";
+            var sshClient = _Options.SSHSettings == null ? vm.CreateSSHClient(this.Request.Host.Host)
+                                                         : new SshClient(_Options.SSHSettings.CreateConnectionInfo());
+
+            if (_Options.TrustedFingerprints.Count != 0)
+            {
+                sshClient.HostKeyReceived += (object sender, Renci.SshNet.Common.HostKeyEventArgs e) =>
+                {
+                    if (_Options.TrustedFingerprints.Count == 0)
+                    {
+                        Logs.Configuration.LogWarning($"SSH host fingerprint for {e.HostKeyName} is untrusted, start BTCPay with -sshtrustedfingerprints \"{Encoders.Hex.EncodeData(e.FingerPrint)}\"");
+                        e.CanTrust = true; // Not a typo, we want the connection to succeed with a warning
+                    }
+                    else
+                    {
+                        e.CanTrust = _Options.IsTrustedFingerprint(e.FingerPrint, e.HostKey);
+                        if (!e.CanTrust)
+                            Logs.Configuration.LogError($"SSH host fingerprint for {e.HostKeyName} is untrusted, start BTCPay with -sshtrustedfingerprints \"{Encoders.Hex.EncodeData(e.FingerPrint)}\"");
+                    }
+                };
+            }
+            else
+            {
+
+            }
+
+            try
+            {
+                sshClient.Connect();
+            }
+            catch (Renci.SshNet.Common.SshAuthenticationException)
+            {
+                ModelState.AddModelError(nameof(vm.Password), "Invalid credentials");
+                sshClient.Dispose();
+                return View(vm);
+            }
+            catch (Exception ex)
+            {
+                var message = ex.Message;
+                if (ex is AggregateException aggrEx && aggrEx.InnerException?.Message != null)
+                {
+                    message = aggrEx.InnerException.Message;
+                }
+                ModelState.AddModelError(nameof(vm.UserName), $"Connection problem ({message})");
+                sshClient.Dispose();
+                return View(vm);
+            }
+
+            var sshCommand = sshClient.CreateCommand(ssh);
+            sshCommand.CommandTimeout = TimeSpan.FromMinutes(1.0);
+            sshCommand.BeginExecute(ar =>
+            {
+                try
+                {
+                    Logs.PayServer.LogInformation("Running SSH command: " + ssh);
+                    var result = sshCommand.EndExecute(ar);
+                    Logs.PayServer.LogInformation("SSH command executed: " + result);
+                }
+                catch (Exception ex)
+                {
+                    Logs.PayServer.LogWarning("Error while executing SSH command: " + ex.Message);
+                }
+                sshClient.Dispose();
+            });
+            return null;
+        }
+
+        private static bool IsAdmin(IList<string> roles)
+        {
+            return roles.Contains(Roles.ServerAdmin, StringComparer.Ordinal);
+        }
+
+        [Route("server/users/{userId}")]
+        [HttpPost]
+        public new async Task<IActionResult> User(string userId, UserViewModel viewModel)
+        {
+            var user = await _UserManager.FindByIdAsync(userId);
+            if (user == null)
+                return NotFound();
+
+            viewModel.StatusMessage = "";
+
+            var admins = await _UserManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+            if (!viewModel.IsAdmin && admins.Count == 1)
+            {
+                viewModel.StatusMessage = "This is the only Admin, so their role can't be removed until another Admin is added.";
+                return View(viewModel); // return
+            }
+
+            var roles = await _UserManager.GetRolesAsync(user);
+            if (viewModel.IsAdmin != IsAdmin(roles))
+            {
+                if (viewModel.IsAdmin)
+                    await _UserManager.AddToRoleAsync(user, Roles.ServerAdmin);
+                else
+                    await _UserManager.RemoveFromRoleAsync(user, Roles.ServerAdmin);
+
+                viewModel.StatusMessage = "User successfully updated";
+            }
+
+            return View(viewModel);
+        }
+
+
+        [Route("server/users/{userId}/delete")]
+        public async Task<IActionResult> DeleteUser(string userId)
+        {
+            var user = userId == null ? null : await _UserManager.FindByIdAsync(userId);
+            if (user == null)
+                return NotFound();
+
+            var roles = await _UserManager.GetRolesAsync(user);
+            if (IsAdmin(roles))
+            {
+                var admins = await _UserManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+                if (admins.Count == 1)
+                {
+                    // return
+                    return View("Confirm", new ConfirmModel("Unable to Delete Last Admin",
+                        "This is the last Admin, so it can't be removed"));
+                }
+
+                return View("Confirm", new ConfirmModel("Delete Admin " + user.Email,
+                    "Are you sure you want to delete this Admin and delete all accounts, users and data associated with the server account?",
+                    "Delete"));
+            }
+            else
+            {
+                return View("Confirm", new ConfirmModel("Delete user " + user.Email,
+                                    "This user will be permanently deleted",
+                                    "Delete"));
+            }
+        }
+
+        [Route("server/users/{userId}/delete")]
+        [HttpPost]
+        public async Task<IActionResult> DeleteUserPost(string userId)
+        {
+            var user = userId == null ? null : await _UserManager.FindByIdAsync(userId);
+            if (user == null)
+                return NotFound();
+            await _UserManager.DeleteAsync(user);
+            await _StoreRepository.CleanUnreachableStores();
+            StatusMessage = "User deleted";
+            return RedirectToAction(nameof(ListUsers));
+        }
+
+        [TempData]
+        public string StatusMessage
+        {
+            get; set;
+        }
+        public IHttpClientFactory HttpClientFactory { get; }
+
+        [Route("server/policies")]
+        public async Task<IActionResult> Policies()
+        {
+            var data = (await _SettingsRepository.GetSettingAsync<PoliciesSettings>()) ?? new PoliciesSettings();
+
+            // load display app dropdown
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                var userId = _UserManager.GetUserId(base.User);
+                var selectList = ctx.Users.Where(user => user.Id == userId)
+                                .SelectMany(s => s.UserStores)
+                                .Select(s => s.StoreData)
+                                .SelectMany(s => s.Apps)
+                                .Select(a => new SelectListItem($"{a.AppType} - {a.Name}", a.Id)).ToList();
+                selectList.Insert(0, new SelectListItem("(None)", null));
+                ViewBag.AppsList = new SelectList(selectList, "Value", "Text", data.RootAppId);
+            }
+
+            return View(data);
+        }
+        [Route("server/policies")]
+        [HttpPost]
+        public async Task<IActionResult> Policies(PoliciesSettings settings)
+        {
+            if (!String.IsNullOrEmpty(settings.RootAppId))
+            {
+                using (var ctx = _ContextFactory.CreateContext())
+                {
+                    var app = ctx.Apps.SingleOrDefault(a => a.Id == settings.RootAppId);
+                    if (app != null)
+                        settings.RootAppType = Enum.Parse<AppType>(app.AppType);
+                    else
+                        settings.RootAppType = null;
+                }
+            }
+            else
+            {
+                // not preserved on client side, but clearing it just in case
+                settings.RootAppType = null;
+            }
+
+            await _SettingsRepository.UpdateSetting(settings);
+            TempData["StatusMessage"] = "Policies updated successfully";
+            return RedirectToAction(nameof(Policies));
+        }
+
+        [Route("server/services")]
+        public async Task<IActionResult> Services()
+        {
+            var result = new ServicesViewModel();
+            result.ExternalServices = _Options.ExternalServices.ToList();
+            foreach (var externalService in _Options.OtherExternalServices)
+            {
+                result.OtherExternalServices.Add(new ServicesViewModel.OtherExternalService()
+                {
+                    Name = externalService.Key,
+                    Link = this.Request.GetAbsoluteUriNoPathBase(externalService.Value).AbsoluteUri
+                });
+            }
+            if (_Options.SSHSettings != null)
+            {
+                result.OtherExternalServices.Add(new ServicesViewModel.OtherExternalService()
+                {
+                    Name = "SSH",
+                    Link = this.Url.Action(nameof(SSHService))
+                });
+            }
+            foreach (var torService in _torServices.Services)
+            {
+                if (torService.VirtualPort == 80)
+                {
+                    result.TorHttpServices.Add(new ServicesViewModel.OtherExternalService()
+                    {
+                        Name = torService.Name,
+                        Link = $"http://{torService.OnionHost}"
+                    });
+                }
+                else if (TryParseAsExternalService(torService, out var externalService))
+                {
+                    result.ExternalServices.Add(externalService);
+                }
+                else
+                {
+                    result.TorOtherServices.Add(new ServicesViewModel.OtherExternalService()
+                    {
+                        Name = torService.Name,
+                        Link = $"{torService.OnionHost}:{torService.VirtualPort}"
+                    });
+                }
+            }
+
+            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)
+        {
+            if (!_dashBoard.IsFullySynched(cryptoCode, out var unusud))
+            {
+                StatusMessage = $"Error: {cryptoCode} is not fully synched";
+                return RedirectToAction(nameof(Services));
+            }
+            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)
+                {
+                    case ExternalServiceTypes.Charge:
+                        return LightningChargeServices(service, connectionString, showQR);
+                    case ExternalServiceTypes.RTL:
+                    case ExternalServiceTypes.Spark:
+                        if (connectionString.AccessKey == null)
+                        {
+                            StatusMessage = $"Error: The access key of the service is not set";
+                            return RedirectToAction(nameof(Services));
+                        }
+                        LightningWalletServices vm = new LightningWalletServices();
+                        vm.ShowQR = showQR;
+                        vm.WalletName = service.DisplayName;
+                        vm.ServiceLink = $"{connectionString.Server}?access-key={connectionString.AccessKey}";
+                        return View("LightningWalletServices", vm);
+                    case ExternalServiceTypes.LNDGRPC:
+                    case ExternalServiceTypes.LNDRest:
+                        return LndServices(service, connectionString, nonce);
+                    default:
+                        throw new NotSupportedException(service.Type.ToString());
+                }
+            }
+            catch (Exception ex)
+            {
+                StatusMessage = $"Error: {ex.Message}";
+                return RedirectToAction(nameof(Services));
+            }
+        }
+
+        private IActionResult LightningChargeServices(ExternalService service, ExternalConnectionString connectionString, bool showQR = false)
+        {
+            ChargeServiceViewModel vm = new ChargeServiceViewModel();
+            vm.Uri = connectionString.Server.AbsoluteUri;
+            vm.APIToken = connectionString.APIToken;
+            var builder = new UriBuilder(connectionString.Server);
+            builder.UserName = "api-token";
+            builder.Password = vm.APIToken;
+            vm.AuthenticatedUri = builder.ToString();
+            return View(nameof(LightningChargeServices), vm);
+        }
+
+        private IActionResult LndServices(ExternalService service, ExternalConnectionString connectionString, uint? nonce)
+        {
+            var model = new LndGrpcServicesViewModel();
+            if (service.Type == ExternalServiceTypes.LNDGRPC)
+            {
+                model.Host = $"{connectionString.Server.DnsSafeHost}:{connectionString.Server.Port}";
+                model.SSL = connectionString.Server.Scheme == "https";
+                model.ConnectionType = "GRPC";
+                model.GRPCSSLCipherSuites = "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256";
+            }
+            else if (service.Type == ExternalServiceTypes.LNDRest)
+            {
+                model.Uri = connectionString.Server.AbsoluteUri;
+                model.ConnectionType = "REST";
+            }
+
+            if (connectionString.CertificateThumbprint != null)
+            {
+                model.CertificateThumbprint = connectionString.CertificateThumbprint;
+            }
+            if (connectionString.Macaroon != null)
+            {
+                model.Macaroon = Encoders.Hex.EncodeData(connectionString.Macaroon);
+            }
+            model.AdminMacaroon = connectionString.Macaroons?.AdminMacaroon?.Hex;
+            model.InvoiceMacaroon = connectionString.Macaroons?.InvoiceMacaroon?.Hex;
+            model.ReadonlyMacaroon = connectionString.Macaroons?.ReadonlyMacaroon?.Hex;
+
+            if (nonce != null)
+            {
+                var configKey = GetConfigKey("lnd", service.ServiceName, service.CryptoCode, nonce.Value);
+                var lnConfig = _LnConfigProvider.GetConfig(configKey);
+                if (lnConfig != null)
+                {
+                    model.QRCodeLink = Request.GetAbsoluteUri(Url.Action(nameof(GetLNDConfig), new { configKey = configKey }));
+                    model.QRCode = $"config={model.QRCodeLink}";
+                }
+            }
+
+            return View(nameof(LndServices), model);
+        }
+
+        private static uint GetConfigKey(string type, string serviceName, string cryptoCode, uint nonce)
+        {
+            return (uint)HashCode.Combine(type, serviceName, cryptoCode, nonce);
+        }
+
+        [Route("lnd-config/{configKey}/lnd.config")]
+        [AllowAnonymous]
+        public IActionResult GetLNDConfig(uint configKey)
+        {
+            var conf = _LnConfigProvider.GetConfig(configKey);
+            if (conf == null)
+                return NotFound();
+            return Json(conf);
+        }
+
+        [Route("server/services/{serviceName}/{cryptoCode}")]
+        [HttpPost]
+        public async Task<IActionResult> ServicePost(string serviceName, string cryptoCode)
+        {
+            if (!_dashBoard.IsFullySynched(cryptoCode, out var unusud))
+            {
+                StatusMessage = $"Error: {cryptoCode} is not fully synched";
+                return RedirectToAction(nameof(Services));
+            }
+            var service = GetService(serviceName, cryptoCode);
+            if (service == null)
+                return NotFound();
+
+            ExternalConnectionString connectionString = null;
+            try
+            {
+                connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type);
+            }
+            catch (Exception ex)
+            {
+                StatusMessage = $"Error: {ex.Message}";
+                return RedirectToAction(nameof(Services));
+            }
+
+            LightningConfigurations confs = new LightningConfigurations();
+            if (service.Type == ExternalServiceTypes.LNDGRPC)
+            {
+                LightningConfiguration grpcConf = new LightningConfiguration();
+                grpcConf.Type = "grpc";
+                grpcConf.Host = connectionString.Server.DnsSafeHost;
+                grpcConf.Port = connectionString.Server.Port;
+                grpcConf.SSL = connectionString.Server.Scheme == "https";
+                confs.Configurations.Add(grpcConf);
+            }
+            else if (service.Type == ExternalServiceTypes.LNDRest)
+            {
+                var restconf = new LNDRestConfiguration();
+                restconf.Type = "lnd-rest";
+                restconf.Uri = connectionString.Server.AbsoluteUri;
+                confs.Configurations.Add(restconf);
+            }
+            else
+                throw new NotSupportedException(service.Type.ToString());
+            var commonConf = (LNDConfiguration)confs.Configurations[confs.Configurations.Count - 1];
+            commonConf.ChainType = _Options.NetworkType.ToString();
+            commonConf.CryptoCode = cryptoCode;
+            commonConf.Macaroon = connectionString.Macaroon == null ? null : Encoders.Hex.EncodeData(connectionString.Macaroon);
+            commonConf.CertificateThumbprint = connectionString.CertificateThumbprint == null ? null : connectionString.CertificateThumbprint;
+            commonConf.AdminMacaroon = connectionString.Macaroons?.AdminMacaroon?.Hex;
+            commonConf.ReadonlyMacaroon = connectionString.Macaroons?.ReadonlyMacaroon?.Hex;
+            commonConf.InvoiceMacaroon = connectionString.Macaroons?.InvoiceMacaroon?.Hex;
+
+            var nonce = RandomUtils.GetUInt32();
+            var configKey = GetConfigKey("lnd", serviceName, cryptoCode, nonce);
+            _LnConfigProvider.KeepConfig(configKey, confs);
+            return RedirectToAction(nameof(Service), new { cryptoCode = cryptoCode, serviceName = serviceName, nonce = nonce });
+        }
+
+        [Route("server/services/ssh")]
+        public IActionResult SSHService(bool downloadKeyFile = false)
+        {
+            var settings = _Options.SSHSettings;
+            if (settings == null)
+                return NotFound();
+            if (downloadKeyFile)
+            {
+                if (!System.IO.File.Exists(settings.KeyFile))
+                    return NotFound();
+                return File(System.IO.File.ReadAllBytes(settings.KeyFile), "application/octet-stream", "id_rsa");
+            }
+
+            var server = Extensions.IsLocalNetwork(settings.Server) ? this.Request.Host.Host : settings.Server;
+            SSHServiceViewModel vm = new SSHServiceViewModel();
+            string port = settings.Port == 22 ? "" : $" -p {settings.Port}";
+            vm.CommandLine = $"ssh {settings.Username}@{server}{port}";
+            vm.Password = settings.Password;
+            vm.KeyFilePassword = settings.KeyFilePassword;
+            vm.HasKeyFile = !string.IsNullOrEmpty(settings.KeyFile);
+            return View(vm);
+        }
+
+        [Route("server/theme")]
+        public async Task<IActionResult> Theme()
+        {
+            var data = (await _SettingsRepository.GetSettingAsync<ThemeSettings>()) ?? new ThemeSettings();
+            return View(data);
+        }
+        [Route("server/theme")]
+        [HttpPost]
+        public async Task<IActionResult> Theme(ThemeSettings settings)
+        {
+            await _SettingsRepository.UpdateSetting(settings);
+            TempData["StatusMessage"] = "Theme settings updated successfully";
+            return View(settings);
+        }
+
+
+        [Route("server/emails")]
+        public async Task<IActionResult> Emails()
+        {
+            var data = (await _SettingsRepository.GetSettingAsync<EmailSettings>()) ?? new EmailSettings();
+            return View(new EmailsViewModel() { Settings = data });
+        }
+
+        [Route("server/emails")]
+        [HttpPost]
+        public async Task<IActionResult> Emails(EmailsViewModel model, string command)
+        {
+            if (!model.Settings.IsComplete())
+            {
+                model.StatusMessage = "Error: Required fields missing";
+                return View(model);
+            }
+
+            if (command == "Test")
+            {
+                try
+                {
+                    var client = model.Settings.CreateSmtpClient();
+                    await client.SendMailAsync(model.Settings.From, model.TestEmail, "BTCPay test", "BTCPay test");
+                    model.StatusMessage = "Email sent to " + model.TestEmail + ", please, verify you received it";
+                }
+                catch (Exception ex)
+                {
+                    model.StatusMessage = "Error: " + ex.Message;
+                }
+                return View(model);
+            }
+            else // if(command == "Save")
+            {
+                await _SettingsRepository.UpdateSetting(model.Settings);
+                model.StatusMessage = "Email settings saved";
+                return View(model);
+            }
+        }
+
+        [Route("server/logs/{file?}")]
+        public async Task<IActionResult> LogsView(string file = null, int offset = 0)
+        {
+            if (offset < 0)
+            {
+                offset = 0;
+            }
+
+            var vm = new LogsViewModel();
+
+            if (string.IsNullOrEmpty(_Options.LogFile))
+            {
+                vm.StatusMessage = "Error: File Logging Option not specified. " +
+                                   "You need to set debuglog and optionally " +
+                                   "debugloglevel in the configuration or through runtime arguments";
+            }
+            else
+            {
+                var di = Directory.GetParent(_Options.LogFile);
+                if (di == null)
+                {
+                    vm.StatusMessage = "Error: Could not load log files";
+                }
+
+                var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(_Options.LogFile);
+                var fileExtension = Path.GetExtension(_Options.LogFile) ?? string.Empty;
+                var logFiles = di.GetFiles($"{fileNameWithoutExtension}*{fileExtension}");
+                vm.LogFileCount = logFiles.Length;
+                vm.LogFiles = logFiles
+                    .OrderBy(info => info.LastWriteTime)
+                    .Skip(offset)
+                    .Take(5)
+                    .ToList();
+                vm.LogFileOffset = offset;
+
+                if (string.IsNullOrEmpty(file))
+                    return View("Logs", vm);
+                vm.Log = "";
+                var path = Path.Combine(di.FullName, file);
+                try
+                {
+                    using (var fileStream = new FileStream(
+                        path,
+                        FileMode.Open,
+                        FileAccess.Read,
+                        FileShare.ReadWrite))
+                    {
+                        using (var reader = new StreamReader(fileStream))
+                        {
+                            vm.Log = await reader.ReadToEndAsync();
+                        }
+                    }
+                }
+                catch
+                {
+                    return NotFound();
+                }
+            }
+
+            return View("Logs", vm);
+        }
+    }
 }

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);
+        }
+    }
+}